Быстрый старт: Добавление доступа к сырому медиа в ваше приложение

В этом кратком руководстве описано, как реализовать необработанный доступ к мультимедиа с помощью пакета SDK для вызовов Службы коммуникации Azure для Unity. Пакет SDK для вызовов Службы коммуникации Azure предлагает API- интерфейсы, позволяющие приложениям создавать собственные видеокадры для отправки или отрисовки необработанных видеокадров от удаленных участников звонка. Это быстрое руководство основывается на Краткое руководство: Добавление видеозвонка 1:1 в приложение для Unity.

Доступ к необработанному видео

Так как приложение создает видеокадры, приложение должно сообщить пакету SDK для вызовов Службы коммуникации Azure о форматах видео, которые может создать приложение. Эта информация позволяет пакету SDK для вызовов Службы коммуникации Azure выбрать лучшую конфигурацию формата видео для условий сети в то время.

Виртуальное видео

Поддерживаемые разрешения видео

1. Выполните действия, описанные в этом кратком руководстве. Добавьте видеозвонок 1:1 в приложение для создания игры Unity. Цель состоит в том, чтобы получить CallAgent объект, готовый для начала вызова. Итоговый код для этого краткого руководства можно найти на сайте GitHub.

2. Создайте массив с VideoFormat помощью VideoStreamPixelFormat, который поддерживает пакет SDK. Если доступны несколько форматов, порядок форматов в списке не влияет или не определяет приоритеты используемых форматов. Критерии выбора формата основаны на внешних факторах, таких как пропускная способность сети.

   var videoStreamFormat = new VideoStreamFormat
   {
       Resolution = VideoStreamResolution.P360, // For VirtualOutgoingVideoStream the width/height should be set using VideoStreamResolution enum
       PixelFormat = VideoStreamPixelFormat.Rgba,
       FramesPerSecond = 15,
       Stride1 = 640 * 4 // It is times 4 because RGBA is a 32-bit format
   };
   VideoStreamFormat[] videoStreamFormats = { videoStreamFormat };
   

3. Создайте RawOutgoingVideoStreamOptions, и задайте Formats с ранее созданным объектом.

   var rawOutgoingVideoStreamOptions = new RawOutgoingVideoStreamOptions
   {
       Formats = videoStreamFormats
   };
   

4. Создайте экземпляр VirtualOutgoingVideoStream, используя экземпляр RawOutgoingVideoStreamOptions, созданный ранее.

   var rawOutgoingVideoStream = new VirtualOutgoingVideoStream(rawOutgoingVideoStreamOptions);
   

5. Подпишитесь на RawOutgoingVideoStream.FormatChanged делегата. Это событие сообщает, когда VideoStreamFormat формат был изменён с одного из видеоформатов, предоставленных в списке.

   rawOutgoingVideoStream.FormatChanged += (object sender, VideoStreamFormatChangedEventArgs args)
   {
       VideoStreamFormat videoStreamFormat = args.Format;
   }
   

6. Подпишитесь на RawOutgoingVideoStream.StateChanged делегат. Это событие сообщает при изменении State.

   rawOutgoingVideoStream.StateChanged += (object sender, VideoStreamFormatChangedEventArgs args)
   {
       CallVideoStream callVideoStream = e.Stream;
   
       switch (callVideoStream.Direction)
       {
           case StreamDirection.Outgoing:
               OnRawOutgoingVideoStreamStateChanged(callVideoStream as OutgoingVideoStream);
               break;
           case StreamDirection.Incoming:
               OnRawIncomingVideoStreamStateChanged(callVideoStream as IncomingVideoStream);
               break;
       }
   }
   

7. Обработка необработанных транзакций состояния исходящего видеопотока, таких как запуск и остановка, и начинает создавать пользовательские видеокадры или приостанавливать алгоритм создания кадров.

   private async void OnRawOutgoingVideoStreamStateChanged(OutgoingVideoStream outgoingVideoStream)
   {
       switch (outgoingVideoStream.State)
       {
           case VideoStreamState.Started:
               switch (outgoingVideoStream.Kind)
               {
                   case VideoStreamKind.VirtualOutgoing:
                       outgoingVideoPlayer.StartGenerateFrames(outgoingVideoStream); // This is where a background worker thread can be started to feed the outgoing video frames.
                       break;
               }
               break;
   
           case VideoStreamState.Stopped:
               switch (outgoingVideoStream.Kind)
               {
                   case VideoStreamKind.VirtualOutgoing:
                       break;
               }
               break;
       }
   }
   

   Ниже приведен пример генератора исходящих видеокадров:

   private unsafe RawVideoFrame GenerateRawVideoFrame(RawOutgoingVideoStream rawOutgoingVideoStream)
   {
       var format = rawOutgoingVideoStream.Format;
       int w = format.Width;
       int h = format.Height;
       int rgbaCapacity = w * h * 4;
   
       var rgbaBuffer = new NativeBuffer(rgbaCapacity);
       rgbaBuffer.GetData(out IntPtr rgbaArrayBuffer, out rgbaCapacity);
   
       byte r = (byte)random.Next(1, 255);
       byte g = (byte)random.Next(1, 255);
       byte b = (byte)random.Next(1, 255);
   
       for (int y = 0; y < h; y++)
       {
           for (int x = 0; x < w*4; x += 4)
           {
               ((byte*)rgbaArrayBuffer)[(w * 4 * y) + x + 0] = (byte)(y % r);
               ((byte*)rgbaArrayBuffer)[(w * 4 * y) + x + 1] = (byte)(y % g);
               ((byte*)rgbaArrayBuffer)[(w * 4 * y) + x + 2] = (byte)(y % b);
               ((byte*)rgbaArrayBuffer)[(w * 4 * y) + x + 3] = 255;
           }
       }
   
       // Call ACS Unity SDK API to deliver the frame
       rawOutgoingVideoStream.SendRawVideoFrameAsync(new RawVideoFrameBuffer() {
           Buffers = new NativeBuffer[] { rgbaBuffer },
           StreamFormat = rawOutgoingVideoStream.Format,
           TimestampInTicks = rawOutgoingVideoStream.TimestampInTicks
       }).Wait();
   
       return new RawVideoFrameBuffer()
       {
           Buffers = new NativeBuffer[] { rgbaBuffer },
           StreamFormat = rawOutgoingVideoStream.Format
       };
   }
   

   Примечание.

   unsafe модификатор используется в этом методе, так как NativeBuffer требуется доступ к собственным ресурсам памяти. Allow unsafe Поэтому в редакторе Unity также необходимо включить параметр.

8. Аналогичным образом можно обрабатывать входящие кадры видео в ответ на событие видеопотока StateChanged.

   private void OnRawIncomingVideoStreamStateChanged(IncomingVideoStream incomingVideoStream)
   {
       switch (incomingVideoStream.State)
       {
           case VideoStreamState.Available:
               {
                   var rawIncomingVideoStream = incomingVideoStream as RawIncomingVideoStream;
                   rawIncomingVideoStream.RawVideoFrameReceived += OnRawVideoFrameReceived;
                   rawIncomingVideoStream.Start();
                   break;
               }
           case VideoStreamState.Stopped:
               break;
           case VideoStreamState.NotAvailable:
               break;
       }
   }
   
   private void OnRawVideoFrameReceived(object sender, RawVideoFrameReceivedEventArgs e)
   {
       incomingVideoPlayer.RenderRawVideoFrame(e.Frame);
   }
   
   public void RenderRawVideoFrame(RawVideoFrame rawVideoFrame)
   {
       var videoFrameBuffer = rawVideoFrame as RawVideoFrameBuffer;
       pendingIncomingFrames.Enqueue(new PendingFrame() {
               frame = rawVideoFrame,
               kind = RawVideoFrameKind.Buffer });
   }
   

9. Настоятельно рекомендуется управлять как входящими, так и исходящими видеокадрами с помощью механизма буферизации, чтобы избежать перегрузки метода обратного MonoBehaviour.Update() вызова, который должен храниться в легком режиме и избежать тяжелых обязанностей ЦП или сети и обеспечить более плавное взаимодействие с видео. Эта необязательная оптимизация остается для разработчиков, чтобы решить, что лучше всего работает в своих сценариях.

   Вот пример того, как входящие кадры могут быть отрисованы в Unity VideoTexture, извлекая Graphics.Blit из внутренней очереди:

   private void Update()
   {
       if (pendingIncomingFrames.TryDequeue(out PendingFrame pendingFrame))
       {
           switch (pendingFrame.kind)
           {
               case RawVideoFrameKind.Buffer:
                   var videoFrameBuffer = pendingFrame.frame as RawVideoFrameBuffer;
                   VideoStreamFormat videoFormat = videoFrameBuffer.StreamFormat;
                   int width = videoFormat.Width;
                   int height = videoFormat.Height;
                   var texture = new Texture2D(width, height, TextureFormat.RGBA32, mipChain: false);
   
                   var buffers = videoFrameBuffer.Buffers;
                   NativeBuffer buffer = buffers.Count > 0 ? buffers[0] : null;
                   buffer.GetData(out IntPtr bytes, out int signedSize);
   
                   texture.LoadRawTextureData(bytes, signedSize);
                   texture.Apply();
   
                   Graphics.Blit(source: texture, dest: rawIncomingVideoRenderTexture);
                   break;
   
               case RawVideoFrameKind.Texture:
                   break;
           }
           pendingFrame.frame.Dispose();
       }
   }
   

Из этого краткого руководства вы узнаете, как реализовать необработанный доступ к мультимедиа с помощью пакета SDK для вызовов Службы коммуникации Azure для Windows. Пакет SDK для вызовов Службы коммуникации Azure предлагает API-интерфейсы, которые позволяют приложениям создавать собственные видеокадры для отправки удаленным участникам звонка. Это краткое руководство основано на кратком руководстве: Добавление видеозвонка 1:1 в ваше приложение для Windows.

Доступ к необработанному аудио

Доступ к необработанным звуковым носителям предоставляет доступ к звуковому потоку входящих вызовов, а также возможность просматривать и отправлять пользовательские исходящие звуковые потоки во время вызова.

Отправка необработанного исходящего звука

Сделайте объект options, указывающий свойства необработанного потока, которые мы хотим отправить.

    RawOutgoingAudioStreamProperties outgoingAudioProperties = new RawOutgoingAudioStreamProperties()
    {
        Format = ACSAudioStreamFormat.Pcm16Bit,
        SampleRate = AudioStreamSampleRate.Hz48000,
        ChannelMode = AudioStreamChannelMode.Stereo,
        BufferDuration = AudioStreamBufferDuration.InMs20
    };
    RawOutgoingAudioStreamOptions outgoingAudioStreamOptions = new RawOutgoingAudioStreamOptions()
    {
        Properties = outgoingAudioProperties
    };

RawOutgoingAudioStream Создайте и подключите его к параметрам соединения звонка, и поток автоматически начнется, когда звонок будет подключен.

    JoinCallOptions options =  JoinCallOptions(); // or StartCallOptions()
    OutgoingAudioOptions outgoingAudioOptions = new OutgoingAudioOptions();
    RawOutgoingAudioStream rawOutgoingAudioStream = new RawOutgoingAudioStream(outgoingAudioStreamOptions);
    outgoingAudioOptions.Stream = rawOutgoingAudioStream;
    options.OutgoingAudioOptions = outgoingAudioOptions;
    // Start or Join call with those call options.

Подключение потока к вызову

Кроме того, можно подключить поток к существующему Call экземпляру.

    await call.StartAudio(rawOutgoingAudioStream);

Начало отправки необработанных примеров

Мы можем начать отправку данных только после того, как состояние потока будет AudioStreamState.Started. Чтобы наблюдать за изменением состояния аудиопотока, добавьте прослушиватель в OnStateChangedListener событие.

    unsafe private void AudioStateChanged(object sender, AudioStreamStateChanged args)
    {
        if (args.AudioStreamState == AudioStreamState.Started)
        {
            // We can now start sending samples.
        }
    }
    outgoingAudioStream.StateChanged += AudioStateChanged;

Когда поток начался, можно начать отправку MemoryBuffer звуковых образцов в вызов. Формат буфера звука должен соответствовать указанным свойствам потока.

    void Start()
    {
        RawOutgoingAudioStreamProperties properties = outgoingAudioStream.Properties;
        RawAudioBuffer buffer;
        new Thread(() =>
        {
            DateTime nextDeliverTime = DateTime.Now;
            while (true)
            {
                MemoryBuffer memoryBuffer = new MemoryBuffer((uint)outgoingAudioStream.ExpectedBufferSizeInBytes);
                using (IMemoryBufferReference reference = memoryBuffer.CreateReference())
                {
                    byte* dataInBytes;
                    uint capacityInBytes;
                    ((IMemoryBufferByteAccess)reference).GetBuffer(out dataInBytes, out capacityInBytes);
                    // Use AudioGraph here to grab data from microphone if you want microphone data
                }
                nextDeliverTime = nextDeliverTime.AddMilliseconds(20);
                buffer = new RawAudioBuffer(memoryBuffer);
                outgoingAudioStream.SendOutgoingAudioBuffer(buffer);
                TimeSpan wait = nextDeliverTime - DateTime.Now;
                if (wait > TimeSpan.Zero)
                {
                    Thread.Sleep(wait);
                }
            }
        }).Start();
    }

Получение необработанного входящего звука

Мы также можем получить образцы аудиопотока вызова как MemoryBuffer, если мы хотим обработать аудиопоток вызова перед воспроизведением. Создайте объект, указывающий RawIncomingAudioStreamOptions свойства необработанного потока, которые мы хотим получить.

    RawIncomingAudioStreamProperties properties = new RawIncomingAudioStreamProperties()
    {
        Format = AudioStreamFormat.Pcm16Bit,
        SampleRate = AudioStreamSampleRate.Hz44100,
        ChannelMode = AudioStreamChannelMode.Stereo
    };
    RawIncomingAudioStreamOptions options = new RawIncomingAudioStreamOptions()
    {
        Properties = properties
    };

Создайте RawIncomingAudioStream и подключите его к параметрам вызова.

    JoinCallOptions options =  JoinCallOptions(); // or StartCallOptions()
    RawIncomingAudioStream rawIncomingAudioStream = new RawIncomingAudioStream(audioStreamOptions);
    IncomingAudioOptions incomingAudioOptions = new IncomingAudioOptions()
    {
        Stream = rawIncomingAudioStream
    };
    options.IncomingAudioOptions = incomingAudioOptions;

Кроме того, можно подключить поток к существующему Call экземпляру.

    await call.startAudio(context, rawIncomingAudioStream);

Чтобы начать получать необработанные аудиобуферы из входящего потока, добавьте слушателей для отслеживания состояния входящего потока и буферизации полученных событий.

    unsafe private void OnAudioStateChanged(object sender, AudioStreamStateChanged args)
    {
        if (args.AudioStreamState == AudioStreamState.Started)
        {
            // When value is `AudioStreamState.STARTED` we'll be able to receive samples.
        }
    }
    private void OnRawIncomingMixedAudioBufferAvailable(object sender, IncomingMixedAudioEventArgs args)
    {
        // Received a raw audio buffers(MemoryBuffer).
        using (IMemoryBufferReference reference = args.IncomingAudioBuffer.Buffer.CreateReference())
        {
            byte* dataInBytes;
            uint capacityInBytes;
            ((IMemoryBufferByteAccess)reference).GetBuffer(out dataInBytes, out capacityInBytes);
            // Process the data using AudioGraph class
        }
    }
    rawIncomingAudioStream.StateChanged += OnAudioStateChanged;
    rawIncomingAudioStream.MixedAudioBufferReceived += OnRawIncomingMixedAudioBufferAvailable;

Доступ к RawVideo

Так как приложение создает видеокадры, приложение должно сообщить пакету SDK для вызовов Службы коммуникации Azure о форматах видео, которые может создать приложение. Эта информация позволяет пакету SDK для вызовов Службы коммуникации Azure выбрать лучшую конфигурацию формата видео для условий сети в то время.

Виртуальное видео

Поддерживаемые разрешения видео

1. Создайте массив VideoFormat, используя VideoStreamPixelFormat, который поддерживает SDK. Если доступны несколько форматов, порядок форматов в списке не влияет или не определяет приоритеты используемых форматов. Критерии выбора формата основаны на внешних факторах, таких как пропускная способность сети.

   var videoStreamFormat = new VideoStreamFormat
   {
       Resolution = VideoStreamResolution.P720, // For VirtualOutgoingVideoStream the width/height should be set using VideoStreamResolution enum
       PixelFormat = VideoStreamPixelFormat.Rgba,
       FramesPerSecond = 30,
       Stride1 = 1280 * 4 // It is times 4 because RGBA is a 32-bit format
   };
   VideoStreamFormat[] videoStreamFormats = { videoStreamFormat };
   

2. Создайте RawOutgoingVideoStreamOptions, и задайте Formats с созданным ранее объектом.

   var rawOutgoingVideoStreamOptions = new RawOutgoingVideoStreamOptions
   {
       Formats = videoStreamFormats
   };
   

3. Создайте экземпляр VirtualOutgoingVideoStream, используя экземпляр RawOutgoingVideoStreamOptions, который вы создали ранее.

   var rawOutgoingVideoStream = new VirtualOutgoingVideoStream(rawOutgoingVideoStreamOptions);
   

4. Подпишитесь на RawOutgoingVideoStream.FormatChanged объект делегирования. Это событие информирует о том, когда VideoStreamFormat был изменён с одного из видеоформатов, указанных в списке.

   rawOutgoingVideoStream.FormatChanged += (object sender, VideoStreamFormatChangedEventArgs args)
   {
       VideoStreamFormat videoStreamFormat = args.Format;
   }
   

5. Создание экземпляра следующего вспомогательного класса для доступа к данным буфера

   [ComImport]
   [Guid("5B0D3235-4DBA-4D44-865E-8F1D0E4FD04D")]
   [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
   unsafe interface IMemoryBufferByteAccess
   {
       void GetBuffer(out byte* buffer, out uint capacity);
   }
   [ComImport]
   [Guid("905A0FEF-BC53-11DF-8C49-001E4FC686DA")]
   [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
   unsafe interface IBufferByteAccess
   {
       void Buffer(out byte* buffer);
   }
   internal static class BufferExtensions
   {
       // For accessing MemoryBuffer
       public static unsafe byte* GetArrayBuffer(IMemoryBuffer memoryBuffer)
       {
           IMemoryBufferReference memoryBufferReference = memoryBuffer.CreateReference();
           var memoryBufferByteAccess = memoryBufferReference as IMemoryBufferByteAccess;
           memoryBufferByteAccess.GetBuffer(out byte* arrayBuffer, out uint arrayBufferCapacity);
           GC.AddMemoryPressure(arrayBufferCapacity);
           return arrayBuffer;
       }
       // For accessing MediaStreamSample
       public static unsafe byte* GetArrayBuffer(IBuffer buffer)
       {
           var bufferByteAccess = buffer as IBufferByteAccess;
           bufferByteAccess.Buffer(out byte* arrayBuffer);
           uint arrayBufferCapacity = buffer.Capacity;
           GC.AddMemoryPressure(arrayBufferCapacity);
           return arrayBuffer;
       }
   }
   

6. Создайте экземпляр следующего вспомогательного класса для генерации случайных RawVideoFrame, используя VideoStreamPixelFormat.Rgba.

   public class VideoFrameSender
   {
       private RawOutgoingVideoStream rawOutgoingVideoStream;
       private RawVideoFrameKind rawVideoFrameKind;
       private Thread frameIteratorThread;
       private Random random = new Random();
       private volatile bool stopFrameIterator = false;
       public VideoFrameSender(RawVideoFrameKind rawVideoFrameKind, RawOutgoingVideoStream rawOutgoingVideoStream)
       {
           this.rawVideoFrameKind = rawVideoFrameKind;
           this.rawOutgoingVideoStream = rawOutgoingVideoStream;
       }
       public async void VideoFrameIterator()
       {
           while (!stopFrameIterator)
           {
               if (rawOutgoingVideoStream != null &&
                   rawOutgoingVideoStream.Format != null &&
                   rawOutgoingVideoStream.State == VideoStreamState.Started)
               {
                   await SendRandomVideoFrameRGBA();
               }
           }
       }
       private async Task SendRandomVideoFrameRGBA()
       {
           uint rgbaCapacity = (uint)(rawOutgoingVideoStream.Format.Width * rawOutgoingVideoStream.Format.Height * 4);
           RawVideoFrame videoFrame = null;
           switch (rawVideoFrameKind)
           {
               case RawVideoFrameKind.Buffer:
                   videoFrame = 
                       GenerateRandomVideoFrameBuffer(rawOutgoingVideoStream.Format, rgbaCapacity);
                   break;
               case RawVideoFrameKind.Texture:
                   videoFrame = 
                       GenerateRandomVideoFrameTexture(rawOutgoingVideoStream.Format, rgbaCapacity);
                   break;
           }
           try
           {
               using (videoFrame)
               {
                   await rawOutgoingVideoStream.SendRawVideoFrameAsync(videoFrame);
               }
           }
           catch (Exception ex)
           {
               string msg = ex.Message;
           }
           try
           {
               int delayBetweenFrames = (int)(1000.0 / rawOutgoingVideoStream.Format.FramesPerSecond);
               await Task.Delay(delayBetweenFrames);
           }
           catch (Exception ex)
           {
               string msg = ex.Message;
           }
       }
       private unsafe RawVideoFrame GenerateRandomVideoFrameBuffer(VideoStreamFormat videoFormat, uint rgbaCapacity)
       {
           var rgbaBuffer = new MemoryBuffer(rgbaCapacity);
           byte* rgbaArrayBuffer = BufferExtensions.GetArrayBuffer(rgbaBuffer);
           GenerateRandomVideoFrame(&rgbaArrayBuffer);
           return new RawVideoFrameBuffer()
           {
               Buffers = new MemoryBuffer[] { rgbaBuffer },
               StreamFormat = videoFormat
           };
       }
       private unsafe RawVideoFrame GenerateRandomVideoFrameTexture(VideoStreamFormat videoFormat, uint rgbaCapacity)
       {
           var timeSpan = new TimeSpan(rawOutgoingVideoStream.TimestampInTicks);
           var rgbaBuffer = new Buffer(rgbaCapacity)
           {
               Length = rgbaCapacity
           };
           byte* rgbaArrayBuffer = BufferExtensions.GetArrayBuffer(rgbaBuffer);
           GenerateRandomVideoFrame(&rgbaArrayBuffer);
           var mediaStreamSample = MediaStreamSample.CreateFromBuffer(rgbaBuffer, timeSpan);
           return new RawVideoFrameTexture()
           {
               Texture = mediaStreamSample,
               StreamFormat = videoFormat
           };
       }
       private unsafe void GenerateRandomVideoFrame(byte** rgbaArrayBuffer)
       {
           int w = rawOutgoingVideoStream.Format.Width;
           int h = rawOutgoingVideoStream.Format.Height;
           byte r = (byte)random.Next(1, 255);
           byte g = (byte)random.Next(1, 255);
           byte b = (byte)random.Next(1, 255);
           int rgbaStride = w * 4;
           for (int y = 0; y < h; y++)
           {
               for (int x = 0; x < rgbaStride; x += 4)
               {
                   (*rgbaArrayBuffer)[(w * 4 * y) + x + 0] = (byte)(y % r);
                   (*rgbaArrayBuffer)[(w * 4 * y) + x + 1] = (byte)(y % g);
                   (*rgbaArrayBuffer)[(w * 4 * y) + x + 2] = (byte)(y % b);
                   (*rgbaArrayBuffer)[(w * 4 * y) + x + 3] = 255;
               }
           }
       }
       public void Start()
       {
           frameIteratorThread = new Thread(VideoFrameIterator);
           frameIteratorThread.Start();
       }
       public void Stop()
       {
           try
           {
               if (frameIteratorThread != null)
               {
                   stopFrameIterator = true;
                   frameIteratorThread.Join();
                   frameIteratorThread = null;
                   stopFrameIterator = false;
               }
           }
           catch (Exception ex)
           {
               string msg = ex.Message;
           }
       }
   }
   

7. Подпишитесь на VideoStream.StateChanged делегат. Это событие сообщает о состоянии текущего потока. Не отправляйте кадры, если состояние не равно VideoStreamState.Started.

   private VideoFrameSender videoFrameSender;
   rawOutgoingVideoStream.StateChanged += (object sender, VideoStreamStateChangedEventArgs args) =>
   {
       CallVideoStream callVideoStream = args.Stream;
       switch (callVideoStream.State)
           {
               case VideoStreamState.Available:
                   // VideoStream has been attached to the call
                   var frameKind = RawVideoFrameKind.Buffer; // Use the frameKind you prefer
                   //var frameKind = RawVideoFrameKind.Texture;
                   videoFrameSender = new VideoFrameSender(frameKind, rawOutgoingVideoStream);
                   break;
               case VideoStreamState.Started:
                   // Start sending frames
                   videoFrameSender.Start();
                   break;
               case VideoStreamState.Stopped:
                   // Stop sending frames
                   videoFrameSender.Stop();
                   break;
           }
   };
   

Видео с общим доступом к экрану

Так как система Windows создает кадры, необходимо реализовать собственную службу переднего плана, чтобы записать кадры и отправить их с помощью API вызовов Службы коммуникации Azure.

Поддерживаемые разрешения видео

Шаги для создания видеотрансляции экрана

1. Создайте массив VideoFormat, используя формат пикселей VideoStream, поддерживаемый SDK. Если доступны несколько форматов, порядок форматов в списке не влияет или не определяет приоритеты используемых форматов. Критерии выбора формата основаны на внешних факторах, таких как пропускная способность сети.

   var videoStreamFormat = new VideoStreamFormat
   {
       Width = 1280, // Width and height can be used for ScreenShareOutgoingVideoStream for custom resolutions or use one of the predefined values inside VideoStreamResolution
       Height = 720,
       //Resolution = VideoStreamResolution.P720,
       PixelFormat = VideoStreamPixelFormat.Rgba,
       FramesPerSecond = 30,
       Stride1 = 1280 * 4 // It is times 4 because RGBA is a 32-bit format.
   };
   VideoStreamFormat[] videoStreamFormats = { videoStreamFormat };
   

2. Создайте RawOutgoingVideoStreamOptions, и задайте VideoFormats с помощью созданного ранее объекта.

   var rawOutgoingVideoStreamOptions = new RawOutgoingVideoStreamOptions
   {
       Formats = videoStreamFormats
   };
   

3. Создайте экземпляр VirtualOutgoingVideoStream, используя созданный ранее экземпляр RawOutgoingVideoStreamOptions.

   var rawOutgoingVideoStream = new ScreenShareOutgoingVideoStream(rawOutgoingVideoStreamOptions);
   

4. Захватите и отправьте видеокадр следующим образом.

   private async Task SendRawVideoFrame()
   {
       RawVideoFrame videoFrame = null;
       switch (rawVideoFrameKind) //it depends on the frame kind you want to send
       {
           case RawVideoFrameKind.Buffer:
               MemoryBuffer memoryBuffer = // Fill it with the content you got from the Windows APIs
               videoFrame = new RawVideoFrameBuffer()
               {
                   Buffers = memoryBuffer // The number of buffers depends on the VideoStreamPixelFormat
                   StreamFormat = rawOutgoingVideoStream.Format
               };
               break;
           case RawVideoFrameKind.Texture:
               MediaStreamSample mediaStreamSample = // Fill it with the content you got from the Windows APIs
               videoFrame = new RawVideoFrameTexture()
               {
                   Texture = mediaStreamSample, // Texture only receive planar buffers
                   StreamFormat = rawOutgoingVideoStream.Format
               };
               break;
       }
   
       try
       {
           using (videoFrame)
           {
               await rawOutgoingVideoStream.SendRawVideoFrameAsync(videoFrame);
           }
       }
       catch (Exception ex)
       {
           string msg = ex.Message;
       }
   
       try
       {
           int delayBetweenFrames = (int)(1000.0 / rawOutgoingVideoStream.Format.FramesPerSecond);
           await Task.Delay(delayBetweenFrames);
       }
       catch (Exception ex)
       {
           string msg = ex.Message;
       }
   }
   

Необработанное входящее видео

Эта функция предоставляет доступ к видеокадрам внутри элементов IncomingVideoStream, чтобы управлять этими потоками локально.

1. Создайте экземпляр IncomingVideoOptions, который настраивается через JoinCallOptions с помощью параметра VideoStreamKind.RawIncoming.

   var frameKind = RawVideoFrameKind.Buffer;  // Use the frameKind you prefer to receive
   var incomingVideoOptions = new IncomingVideoOptions
   {
       StreamKind = VideoStreamKind.RawIncoming,
       FrameKind = frameKind
   };
   var joinCallOptions = new JoinCallOptions
   {
       IncomingVideoOptions = incomingVideoOptions
   };
   

2. После получения события ParticipantsUpdatedEventArgs прикрепите делегата RemoteParticipant.VideoStreamStateChanged. Это событие сообщает о состоянии IncomingVideoStream объектов.

   private List<RemoteParticipant> remoteParticipantList;
   private void OnRemoteParticipantsUpdated(object sender, ParticipantsUpdatedEventArgs args)
   {
       foreach (RemoteParticipant remoteParticipant in args.AddedParticipants)
       {
           IReadOnlyList<IncomingVideoStream> incomingVideoStreamList = remoteParticipant.IncomingVideoStreams; // Check if there are IncomingVideoStreams already before attaching the delegate
           foreach (IncomingVideoStream incomingVideoStream in incomingVideoStreamList)
           {
               OnRawIncomingVideoStreamStateChanged(incomingVideoStream);
           }
           remoteParticipant.VideoStreamStateChanged += OnVideoStreamStateChanged;
           remoteParticipantList.Add(remoteParticipant); // If the RemoteParticipant ref is not kept alive the VideoStreamStateChanged events are going to be missed
       }
       foreach (RemoteParticipant remoteParticipant in args.RemovedParticipants)
       {
           remoteParticipant.VideoStreamStateChanged -= OnVideoStreamStateChanged;
           remoteParticipantList.Remove(remoteParticipant);
       }
   }
   private void OnVideoStreamStateChanged(object sender, VideoStreamStateChangedEventArgs args)
   {
       CallVideoStream callVideoStream = args.Stream;
       OnRawIncomingVideoStreamStateChanged(callVideoStream as RawIncomingVideoStream);
   }
   private void OnRawIncomingVideoStreamStateChanged(RawIncomingVideoStream rawIncomingVideoStream)
   {
       switch (incomingVideoStream.State)
       {
           case VideoStreamState.Available:
               // There is a new IncomingVideoStream
               rawIncomingVideoStream.RawVideoFrameReceived += OnVideoFrameReceived;
               rawIncomingVideoStream.Start();
               break;
           case VideoStreamState.Started:
               // Will start receiving video frames
               break;
           case VideoStreamState.Stopped:
               // Will stop receiving video frames
               break;
           case VideoStreamState.NotAvailable:
               // The IncomingVideoStream should not be used anymore
               rawIncomingVideoStream.RawVideoFrameReceived -= OnVideoFrameReceived;
               break;
       }
   }
   

3. На тот момент IncomingVideoStream имеет делегат VideoStreamState.Available состояния присоединения RawIncomingVideoStream.RawVideoFrameReceived, как показано на предыдущем шаге. Это предоставляет новые RawVideoFrame объекты.

   private async void OnVideoFrameReceived(object sender, RawVideoFrameReceivedEventArgs args)
   {
       RawVideoFrame videoFrame = args.Frame;
       switch (videoFrame.Kind) // The type will be whatever was configured on the IncomingVideoOptions
       {
           case RawVideoFrameKind.Buffer:
               // Render/Modify/Save the video frame
               break;
           case RawVideoFrameKind.Texture:
               // Render/Modify/Save the video frame
               break;
       }
   }
   

Быстрый старт: попробуйте тестовое приложение

• Необработанное видео

В этом кратком руководстве описано, как реализовать необработанный доступ к мультимедиа с помощью пакета SDK для вызовов Службы коммуникации Azure для Android.

Пакет SDK для вызовов Службы коммуникации Azure предлагает API-интерфейсы, которые позволяют приложениям создавать собственные видеокадры для отправки удаленным участникам звонка.

Это руководство основа на Краткое руководство: Добавление видеозвонка 1:1 в ваше приложение для Android.

Доступ RawAudio

Доступ к необработанным звуковым носителям предоставляет доступ к входящему аудиопотоку звонка, а также возможность просматривать и отправлять пользовательские исходящие звуковые потоки во время звонка.

Отправка необработанного исходящего звука

Сделайте объект options, указывающий свойства необработанного потока, которые мы хотим отправить.

    RawOutgoingAudioStreamProperties outgoingAudioProperties = new RawOutgoingAudioStreamProperties()
                .setAudioFormat(AudioStreamFormat.PCM16_BIT)
                .setSampleRate(AudioStreamSampleRate.HZ44100)
                .setChannelMode(AudioStreamChannelMode.STEREO)
                .setBufferDuration(AudioStreamBufferDuration.IN_MS20);

    RawOutgoingAudioStreamOptions outgoingAudioStreamOptions = new RawOutgoingAudioStreamOptions()
                .setProperties(outgoingAudioProperties);

RawOutgoingAudioStream Создайте и подключите его для присоединения к параметрам вызова, а поток автоматически запускается при подключении звонка.

    JoinCallOptions options = JoinCallOptions() // or StartCallOptions()

    OutgoingAudioOptions outgoingAudioOptions = new OutgoingAudioOptions();
    RawOutgoingAudioStream rawOutgoingAudioStream = new RawOutgoingAudioStream(outgoingAudioStreamOptions);

    outgoingAudioOptions.setStream(rawOutgoingAudioStream);
    options.setOutgoingAudioOptions(outgoingAudioOptions);

    // Start or Join call with those call options.

Подключение потока к вызову

Кроме того, можно подключить поток к существующему Call экземпляру.

    CompletableFuture<Void> result = call.startAudio(context, rawOutgoingAudioStream);

Начало отправки необработанных примеров

Мы можем начать отправку данных только после того, как состояние потока будет AudioStreamState.STARTED. Чтобы наблюдать за изменением состояния аудиопотока, добавьте прослушиватель для события OnStateChangedListener.

    private void onStateChanged(PropertyChangedEvent propertyChangedEvent) {
        // When value is `AudioStreamState.STARTED` we'll be able to send audio samples.
    }

    rawOutgoingAudioStream.addOnStateChangedListener(this::onStateChanged)

Когда поток начался, можно начать отправлять java.nio.ByteBuffer аудиообразцы в вызов.

Формат буфера звука должен соответствовать указанным свойствам потока.

    Thread thread = new Thread(){
        public void run() {
            RawAudioBuffer buffer;
            Calendar nextDeliverTime = Calendar.getInstance();
            while (true)
            {
                nextDeliverTime.add(Calendar.MILLISECOND, 20);
                byte data[] = new byte[outgoingAudioStream.getExpectedBufferSizeInBytes()];
                //can grab microphone data from AudioRecord
                ByteBuffer dataBuffer = ByteBuffer.allocateDirect(outgoingAudioStream.getExpectedBufferSizeInBytes());
                dataBuffer.rewind();
                buffer = new RawAudioBuffer(dataBuffer);
                outgoingAudioStream.sendOutgoingAudioBuffer(buffer);
                long wait = nextDeliverTime.getTimeInMillis() - Calendar.getInstance().getTimeInMillis();
                if (wait > 0)
                {
                    try {
                        Thread.sleep(wait);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    };
    thread.start();

Получение необработанного входящего звука

Мы также можем получать примеры аудиопотока вызова в формате java.nio.ByteBuffer, если мы хотим обработать звук перед воспроизведением.

Создайте объект, указывающий RawIncomingAudioStreamOptions свойства необработанного потока, которые мы хотим получить.

    RawIncomingAudioStreamOptions options = new RawIncomingAudioStreamOptions();
    RawIncomingAudioStreamProperties properties = new RawIncomingAudioStreamProperties()
                .setAudioFormat(AudioStreamFormat.PCM16_BIT)
                .setSampleRate(AudioStreamSampleRate.HZ44100)
                .setChannelMode(AudioStreamChannelMode.STEREO);
    options.setProperties(properties);

Создайте RawIncomingAudioStream и подключите его к настройкам соединения вызова

    JoinCallOptions options =  JoinCallOptions() // or StartCallOptions()
    IncomingAudioOptions incomingAudioOptions = new IncomingAudioOptions();

    RawIncomingAudioStream rawIncomingAudioStream = new RawIncomingAudioStream(audioStreamOptions);
    incomingAudioOptions.setStream(rawIncomingAudioStream);
    options.setIncomingAudioOptions(incomingAudioOptions);

Кроме того, можно подключить поток к существующему Call экземпляру.

    CompletableFuture<Void> result = call.startAudio(context, rawIncomingAudioStream);

Для начала получения необработанных звуковых буферов из входящего потока добавьте слушателей к входящему потоку, чтобы буферизовать полученные события.

    private void onStateChanged(PropertyChangedEvent propertyChangedEvent) {
        // When value is `AudioStreamState.STARTED` we'll be able to receive samples.
    }

    private void onMixedAudioBufferReceived(IncomingMixedAudioEvent incomingMixedAudioEvent) {
        // Received a raw audio buffers(java.nio.ByteBuffer).
    }

    rawIncomingAudioStream.addOnStateChangedListener(this::onStateChanged);
    rawIncomingAudioStream.addMixedAudioBufferReceivedListener(this::onMixedAudioBufferReceived);

Также важно помнить, чтобы остановить аудиопоток в текущем экземпляре вызова Call :

    CompletableFuture<Void> result = call.stopAudio(context, rawIncomingAudioStream);

Доступ к исходному видео (RawVideo)

Так как приложение создает видеокадры, приложение должно сообщить пакету SDK для вызовов Службы коммуникации Azure о форматах видео, которые может создать приложение. Эта информация позволяет пакету SDK для вызовов Службы коммуникации Azure выбрать лучшую конфигурацию формата видео для условий сети в то время.

Виртуальное видео

Поддерживаемые разрешения видео

1. Создайте массив с VideoFormat помощью VideoStreamPixelFormat, который поддерживает пакет SDK.

   Если доступны несколько форматов, порядок форматов в списке не влияет или не определяет приоритеты используемых форматов. Критерии выбора формата основаны на внешних факторах, таких как пропускная способность сети.

   VideoStreamFormat videoStreamFormat = new VideoStreamFormat();
   videoStreamFormat.setResolution(VideoStreamResolution.P360);
   videoStreamFormat.setPixelFormat(VideoStreamPixelFormat.RGBA);
   videoStreamFormat.setFramesPerSecond(framerate);
   videoStreamFormat.setStride1(w * 4); // It is times 4 because RGBA is a 32-bit format
   
   List<VideoStreamFormat> videoStreamFormats = new ArrayList<>();
   videoStreamFormats.add(videoStreamFormat);
   

2. Создайте RawOutgoingVideoStreamOptions, а затем задайте Formats с ранее созданным объектом.

   RawOutgoingVideoStreamOptions rawOutgoingVideoStreamOptions = new RawOutgoingVideoStreamOptions();
   rawOutgoingVideoStreamOptions.setFormats(videoStreamFormats);
   

3. Создайте экземпляр VirtualOutgoingVideoStream, используя ранее созданный экземпляр RawOutgoingVideoStreamOptions.

   VirtualOutgoingVideoStream rawOutgoingVideoStream = new VirtualOutgoingVideoStream(rawOutgoingVideoStreamOptions);
   

4. Подпишитесь на RawOutgoingVideoStream.addOnFormatChangedListener делегат. Это событие сообщает, когда VideoStreamFormat был изменён с одного из форматов видео, указанных в списке.

   virtualOutgoingVideoStream.addOnFormatChangedListener((VideoStreamFormatChangedEvent args) -> 
   {
       VideoStreamFormat videoStreamFormat = args.Format;
   });
   

5. Создайте экземпляр следующего вспомогательного класса для генерации случайных RawVideoFrame, используя VideoStreamPixelFormat.RGBA

   public class VideoFrameSender
   {
       private RawOutgoingVideoStream rawOutgoingVideoStream;
       private Thread frameIteratorThread;
       private Random random = new Random();
       private volatile boolean stopFrameIterator = false;
   
       public VideoFrameSender(RawOutgoingVideoStream rawOutgoingVideoStream)
       {
           this.rawOutgoingVideoStream = rawOutgoingVideoStream;
       }
   
       public void VideoFrameIterator()
       {
           while (!stopFrameIterator)
           {
               if (rawOutgoingVideoStream != null && 
                   rawOutgoingVideoStream.getFormat() != null && 
                   rawOutgoingVideoStream.getState() == VideoStreamState.STARTED)
               {
                   SendRandomVideoFrameRGBA();
               }
           }
       }
   
       private void SendRandomVideoFrameRGBA()
       {
           int rgbaCapacity = rawOutgoingVideoStream.getFormat().getWidth() * rawOutgoingVideoStream.getFormat().getHeight() * 4;
   
           RawVideoFrame videoFrame = GenerateRandomVideoFrameBuffer(rawOutgoingVideoStream.getFormat(), rgbaCapacity);
   
           try
           {
               rawOutgoingVideoStream.sendRawVideoFrame(videoFrame).get();
   
               int delayBetweenFrames = (int)(1000.0 / rawOutgoingVideoStream.getFormat().getFramesPerSecond());
               Thread.sleep(delayBetweenFrames);
           }
           catch (Exception ex)
           {
               String msg = ex.getMessage();
           }
           finally
           {
               videoFrame.close();
           }
       }
   
       private RawVideoFrame GenerateRandomVideoFrameBuffer(VideoStreamFormat videoStreamFormat, int rgbaCapacity)
       {
           ByteBuffer rgbaBuffer = ByteBuffer.allocateDirect(rgbaCapacity); // Only allocateDirect ByteBuffers are allowed
           rgbaBuffer.order(ByteOrder.nativeOrder());
   
           GenerateRandomVideoFrame(rgbaBuffer, rgbaCapacity);
   
           RawVideoFrameBuffer videoFrameBuffer = new RawVideoFrameBuffer();
           videoFrameBuffer.setBuffers(Arrays.asList(rgbaBuffer));
           videoFrameBuffer.setStreamFormat(videoStreamFormat);
   
           return videoFrameBuffer;
       }
   
       private void GenerateRandomVideoFrame(ByteBuffer rgbaBuffer, int rgbaCapacity)
       {
           int w = rawOutgoingVideoStream.getFormat().getWidth();
           int h = rawOutgoingVideoStream.getFormat().getHeight();
   
           byte rVal = (byte)random.nextInt(255);
           byte gVal = (byte)random.nextInt(255);
           byte bVal = (byte)random.nextInt(255);
           byte aVal = (byte)255;
   
           byte[] rgbaArrayBuffer = new byte[rgbaCapacity];
   
           int rgbaStride = w * 4;
   
           for (int y = 0; y < h; y++)
           {
               for (int x = 0; x < rgbaStride; x += 4)
               {
                   rgbaArrayBuffer[(w * 4 * y) + x + 0] = rVal;
                   rgbaArrayBuffer[(w * 4 * y) + x + 1] = gVal;
                   rgbaArrayBuffer[(w * 4 * y) + x + 2] = bVal;
                   rgbaArrayBuffer[(w * 4 * y) + x + 3] = aVal;
               }
           }
   
           rgbaBuffer.put(rgbaArrayBuffer);
           rgbaBuffer.rewind();
       }
   
       public void Start()
       {
           frameIteratorThread = new Thread(this::VideoFrameIterator);
           frameIteratorThread.start();
       }
   
       public void Stop()
       {
           try
           {
               if (frameIteratorThread != null)
               {
                   stopFrameIterator = true;
   
                   frameIteratorThread.join();
                   frameIteratorThread = null;
   
                   stopFrameIterator = false;
               }
           }
           catch (InterruptedException ex)
           {
               String msg = ex.getMessage();
           }
       }
   }
   

6. Подпишитесь на делегата VideoStream.addOnStateChangedListener. Этот делегат информирует о состоянии текущего потока. Не отправляйте кадры, если состояние не равно VideoStreamState.STARTED.

   private VideoFrameSender videoFrameSender;
   
   rawOutgoingVideoStream.addOnStateChangedListener((VideoStreamStateChangedEvent args) ->
   {
       CallVideoStream callVideoStream = args.getStream();
   
       switch (callVideoStream.getState())
       {
           case AVAILABLE:
               videoFrameSender = new VideoFrameSender(rawOutgoingVideoStream);
               break;
           case STARTED:
               // Start sending frames
               videoFrameSender.Start();
               break;
           case STOPPED:
               // Stop sending frames
               videoFrameSender.Stop();
               break;
       }
   });
   

Видео ScreenShare

Так как система Windows создает кадры, необходимо реализовать собственную службу переднего плана, чтобы записать кадры и отправить их с помощью API вызовов Службы коммуникации Azure.

Поддерживаемые разрешения видео

Шаги по созданию видеопотока с демонстрацией экрана

1. Создайте массив VideoFormat, используя VideoStreamPixelFormat, который поддерживается SDK.

   Если доступны несколько форматов, порядок форматов в списке не влияет или не определяет приоритеты используемых форматов. Критерии выбора формата основаны на внешних факторах, таких как пропускная способность сети.

   VideoStreamFormat videoStreamFormat = new VideoStreamFormat();
   videoStreamFormat.setWidth(1280); // Width and height can be used for ScreenShareOutgoingVideoStream for custom resolutions or use one of the predefined values inside VideoStreamResolution
   videoStreamFormat.setHeight(720);
   //videoStreamFormat.setResolution(VideoStreamResolution.P360);
   videoStreamFormat.setPixelFormat(VideoStreamPixelFormat.RGBA);
   videoStreamFormat.setFramesPerSecond(framerate);
   videoStreamFormat.setStride1(w * 4); // It is times 4 because RGBA is a 32-bit format
   
   List<VideoStreamFormat> videoStreamFormats = new ArrayList<>();
   videoStreamFormats.add(videoStreamFormat);
   

2. Создайте RawOutgoingVideoStreamOptions, и задайте VideoFormats в созданный ранее объект.

   RawOutgoingVideoStreamOptions rawOutgoingVideoStreamOptions = new RawOutgoingVideoStreamOptions();
   rawOutgoingVideoStreamOptions.setFormats(videoStreamFormats);
   

3. Создайте экземпляр VirtualOutgoingVideoStream, используя экземпляр RawOutgoingVideoStreamOptions, который был создан ранее.

   ScreenShareOutgoingVideoStream rawOutgoingVideoStream = new ScreenShareOutgoingVideoStream(rawOutgoingVideoStreamOptions);
   

4. Захватите и отправьте видеокадр следующим образом.

   private void SendRawVideoFrame()
   {
       ByteBuffer byteBuffer = // Fill it with the content you got from the Windows APIs
       RawVideoFrameBuffer videoFrame = new RawVideoFrameBuffer();
       videoFrame.setBuffers(Arrays.asList(byteBuffer)); // The number of buffers depends on the VideoStreamPixelFormat
       videoFrame.setStreamFormat(rawOutgoingVideoStream.getFormat());
   
       try
       {
           rawOutgoingVideoStream.sendRawVideoFrame(videoFrame).get();
       }
       catch (Exception ex)
       {
           String msg = ex.getMessage();
       }
       finally
       {
           videoFrame.close();
       }
   }
   

Необработанное входящее видео

Эта функция предоставляет доступ к видеокадрам внутри IncomingVideoStream объектов для локального управления этими кадрами

1. Создайте экземпляр IncomingVideoOptions, который задаётся через JoinCallOptions с параметром VideoStreamKind.RawIncoming.

   IncomingVideoOptions incomingVideoOptions = new IncomingVideoOptions()
           .setStreamType(VideoStreamKind.RAW_INCOMING);
   
   JoinCallOptions joinCallOptions = new JoinCallOptions()
           .setIncomingVideoOptions(incomingVideoOptions);
   

2. После получения делегата ParticipantsUpdatedEventArgs подключения RemoteParticipant.VideoStreamStateChanged события. Это событие сообщает о состоянии IncomingVideoStream объекта.

   private List<RemoteParticipant> remoteParticipantList;
   
   private void OnRemoteParticipantsUpdated(ParticipantsUpdatedEventArgs args)
   {
       for (RemoteParticipant remoteParticipant : args.getAddedParticipants())
       {
           List<IncomingVideoStream> incomingVideoStreamList = remoteParticipant.getIncomingVideoStreams(); // Check if there are IncomingVideoStreams already before attaching the delegate
           for (IncomingVideoStream incomingVideoStream : incomingVideoStreamList)
           {
               OnRawIncomingVideoStreamStateChanged(incomingVideoStream);
           }
   
           remoteParticipant.addOnVideoStreamStateChanged(this::OnVideoStreamStateChanged);
           remoteParticipantList.add(remoteParticipant); // If the RemoteParticipant ref is not kept alive the VideoStreamStateChanged events are going to be missed
       }
   
       for (RemoteParticipant remoteParticipant : args.getRemovedParticipants())
       {
           remoteParticipant.removeOnVideoStreamStateChanged(this::OnVideoStreamStateChanged);
           remoteParticipantList.remove(remoteParticipant);
       }
   }
   
   private void OnVideoStreamStateChanged(object sender, VideoStreamStateChangedEventArgs args)
   {
       CallVideoStream callVideoStream = args.getStream();
   
       OnRawIncomingVideoStreamStateChanged((RawIncomingVideoStream) callVideoStream);
   }
   
   private void OnRawIncomingVideoStreamStateChanged(RawIncomingVideoStream rawIncomingVideoStream)
   {
       switch (incomingVideoStream.State)
       {
           case AVAILABLE:
               // There is a new IncomingvideoStream
               rawIncomingVideoStream.addOnRawVideoFrameReceived(this::OnVideoFrameReceived);
               rawIncomingVideoStream.Start();
   
               break;
           case STARTED:
               // Will start receiving video frames
               break;
           case STOPPED:
               // Will stop receiving video frames
               break;
           case NOT_AVAILABLE:
               // The IncomingvideoStream should not be used anymore
               rawIncomingVideoStream.removeOnRawVideoFrameReceived(this::OnVideoFrameReceived);
   
               break;
       }
   }
   

3. На тот момент IncomingVideoStream имеет VideoStreamState.Available состояние, присоединяя делегата RawIncomingVideoStream.RawVideoFrameReceived, как показано на предыдущем шаге. Этот делегат предоставляет новые RawVideoFrame объекты.

   private void OnVideoFrameReceived(RawVideoFrameReceivedEventArgs args)
   {
       // Render/Modify/Save the video frame
       RawVideoFrameBuffer videoFrame = (RawVideoFrameBuffer) args.getFrame();
   }
   

Начало работы: Попробуйте тестовое приложение

• Необработанное видео

Из этого краткого руководства вы узнаете, как реализовать необработанный доступ к мультимедиа с помощью пакета SDK для вызовов Службы коммуникации Azure для iOS.

Пакет SDK для вызовов Службы коммуникации Azure предлагает API-интерфейсы, которые позволяют приложениям создавать собственные видеокадры для отправки удаленным участникам звонка.

В этом кратком руководстве расширяются темы из Краткое руководство: добавление видеозвонка 1:1 в приложение для iOS.

Доступ к RawAudio

Доступ к необработанным звуковым носителям предоставляет доступ к звуковому потоку входящих вызовов, а также возможность просматривать и отправлять пользовательские исходящие звуковые потоки во время вызова.

Отправка необработанного исходящего звука

Сделайте объект options, указывающий свойства необработанного потока, которые мы хотим отправить.

    let outgoingAudioStreamOptions = RawOutgoingAudioStreamOptions()
    let properties = RawOutgoingAudioStreamProperties()
    properties.sampleRate = .hz44100
    properties.bufferDuration = .inMs20
    properties.channelMode = .mono
    properties.format = .pcm16Bit
    outgoingAudioStreamOptions.properties = properties

Создайте RawOutgoingAudioStream и подключите его к параметрам соединения вызова. Поток автоматически запускается, когда установлено соединение.

    let options = JoinCallOptions() // or StartCallOptions()

    let outgoingAudioOptions = OutgoingAudioOptions()
    self.rawOutgoingAudioStream = RawOutgoingAudioStream(rawOutgoingAudioStreamOptions: outgoingAudioStreamOptions)
    outgoingAudioOptions.stream = self.rawOutgoingAudioStream
    options.outgoingAudioOptions = outgoingAudioOptions

    // Start or Join call passing the options instance.

Подключение потока к вызову

Кроме того, можно подключить поток к существующему Call экземпляру.

    call.startAudio(stream: self.rawOutgoingAudioStream) { error in 
        // Stream attached to `Call`.
    }

Начало отправки необработанных примеров

Мы можем начать отправку данных только после того, как состояние потока будет AudioStreamState.started. Чтобы отслеживать изменение состояния аудиопотока, мы реализуем RawOutgoingAudioStreamDelegate. И задайте его в качестве делегата стрима.

    func rawOutgoingAudioStream(_ rawOutgoingAudioStream: RawOutgoingAudioStream,
                                didChangeState args: AudioStreamStateChangedEventArgs) {
        // When value is `AudioStreamState.started` we will be able to send audio samples.
    }

    self.rawOutgoingAudioStream.delegate = DelegateImplementer()

или использовать основанное на замыкании

    self.rawOutgoingAudioStream.events.onStateChanged = { args in
        // When value is `AudioStreamState.started` we will be able to send audio samples.
    }

Когда поток начнется, можно начать отправку AVAudioPCMBuffer аудио образцов в вызов.

Формат буфера звука должен соответствовать указанным свойствам потока.

    protocol SamplesProducer {
        func produceSample(_ currentSample: Int, 
                           options: RawOutgoingAudioStreamOptions) -> AVAudioPCMBuffer
    }

    // Let's use a simple Tone data producer as example.
    // Producing PCM buffers.
    func produceSamples(_ currentSample: Int,
                        stream: RawOutgoingAudioStream,
                        options: RawOutgoingAudioStreamOptions) -> AVAudioPCMBuffer {
        let sampleRate = options.properties.sampleRate
        let channelMode = options.properties.channelMode
        let bufferDuration = options.properties.bufferDuration
        let numberOfChunks = UInt32(1000 / bufferDuration.value)
        let bufferFrameSize = UInt32(sampleRate.valueInHz) / numberOfChunks
        let frequency = 400

        guard let format = AVAudioFormat(commonFormat: .pcmFormatInt16,
                                         sampleRate: sampleRate.valueInHz,
                                         channels: channelMode.channelCount,
                                         interleaved: channelMode == .stereo) else {
            fatalError("Failed to create PCM Format")
        }

        guard let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: bufferFrameSize) else {
            fatalError("Failed to create PCM buffer")
        }

        buffer.frameLength = bufferFrameSize

        let factor: Double = ((2 as Double) * Double.pi) / (sampleRate.valueInHz/Double(frequency))
        var interval = 0
        for sampleIdx in 0..<Int(buffer.frameCapacity * channelMode.channelCount) {
            let sample = sin(factor * Double(currentSample + interval))
            // Scale to maximum amplitude. Int16.max is 37,767.
            let value = Int16(sample * Double(Int16.max))
            
            guard let underlyingByteBuffer = buffer.mutableAudioBufferList.pointee.mBuffers.mData else {
                continue
            }
            underlyingByteBuffer.assumingMemoryBound(to: Int16.self).advanced(by: sampleIdx).pointee = value
            interval += channelMode == .mono ? 2 : 1
        }

        return buffer
    }

    final class RawOutgoingAudioSender {
        let stream: RawOutgoingAudioStream
        let options: RawOutgoingAudioStreamOptions
        let producer: SamplesProducer

        private var timer: Timer?
        private var currentSample: Int = 0
        private var currentTimestamp: Int64 = 0

        init(stream: RawOutgoingAudioStream,
             options: RawOutgoingAudioStreamOptions,
             producer: SamplesProducer) {
            self.stream = stream
            self.options = options
            self.producer = producer
        }

        func start() {
            let properties = self.options.properties
            let interval = properties.bufferDuration.timeInterval

            let channelCount = AVAudioChannelCount(properties.channelMode.channelCount)
            let format = AVAudioFormat(commonFormat: .pcmFormatInt16,
                                       sampleRate: properties.sampleRate.valueInHz,
                                       channels: channelCount,
                                       interleaved: channelCount > 1)!
            self.timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
                guard let self = self else { return }
                let sample = self.producer.produceSamples(self.currentSample, options: self.options)
                let rawBuffer = RawAudioBuffer()
                rawBuffer.buffer = sample
                rawBuffer.timestampInTicks = self.currentTimestamp
                self.stream.send(buffer: rawBuffer, completionHandler: { error in
                    if let error = error {
                        // Handle possible error.
                    }
                })

                self.currentTimestamp += Int64(properties.bufferDuration.value)
                self.currentSample += 1
            }
        }

        func stop() {
            self.timer?.invalidate()
            self.timer = nil
        }

        deinit {
            stop()
        }
    }

Также важно помнить, чтобы остановить аудиопоток в текущем экземпляре вызова Call :

    call.stopAudio(stream: self.rawOutgoingAudioStream) { error in 
        // Stream detached from `Call` and stopped.
    }

Захват образцов микрофона

С помощью Apple AVAudioEngine можно захватывать кадры с микрофона, подключившись к узлу ввода аудиодвигателя. Захват данных микрофона и возможность использования необработанного звукового сигнала позволяют нам обработать звук перед отправкой его в вызов.

    import AVFoundation
    import AzureCommunicationCalling

    enum MicrophoneSenderError: Error {
        case notMatchingFormat
    }

    final class MicrophoneDataSender {
        private let stream: RawOutgoingAudioStream
        private let properties: RawOutgoingAudioStreamProperties
        private let format: AVAudioFormat
        private let audioEngine: AVAudioEngine = AVAudioEngine()

        init(properties: RawOutgoingAudioStreamProperties) throws {
            // This can be different depending on which device we are running or value set for
            // `try AVAudioSession.sharedInstance().setPreferredSampleRate(...)`.
            let nodeFormat = self.audioEngine.inputNode.outputFormat(forBus: 0)
            let matchingSampleRate = AudioSampleRate.allCases.first(where: { $0.valueInHz == nodeFormat.sampleRate })
            guard let inputNodeSampleRate = matchingSampleRate else {
                throw MicrophoneSenderError.notMatchingFormat
            }

            // Override the sample rate to one that matches audio session (Audio engine input node frequency).
            properties.sampleRate = inputNodeSampleRate

            let options = RawOutgoingAudioStreamOptions()
            options.properties = properties

            self.stream = RawOutgoingAudioStream(rawOutgoingAudioStreamOptions: options)
            let channelCount = AVAudioChannelCount(properties.channelMode.channelCount)
            self.format = AVAudioFormat(commonFormat: .pcmFormatInt16,
                                        sampleRate: properties.sampleRate.valueInHz,
                                        channels: channelCount,
                                        interleaved: channelCount > 1)!
            self.properties = properties
        }

        func start() throws {
            guard !self.audioEngine.isRunning else {
                return
            }

            // Install tap documentations states that we can get between 100 and 400 ms of data.
            let framesFor100ms = AVAudioFrameCount(self.format.sampleRate * 0.1)

            // Note that some formats may not be allowed by `installTap`, so we have to specify the 
            // correct properties.
            self.audioEngine.inputNode.installTap(onBus: 0, bufferSize: framesFor100ms, 
                                                  format: self.format) { [weak self] buffer, _ in
                guard let self = self else { return }
                
                let rawBuffer = RawAudioBuffer()
                rawBuffer.buffer = buffer
                // Although we specified either 10ms or 20ms, we allow sending up to 100ms of data
                // as long as it can be evenly divided by the specified size.
                self.stream.send(buffer: rawBuffer) { error in
                    if let error = error {
                        // Handle error
                    }
                }
            }

            try audioEngine.start()
        }

        func stop() {
            audioEngine.stop()
        }
    }

С помощью этого небольшого примера мы узнали, как можно записать данные микрофона AVAudioEngine и отправить эти образцы на вызов с помощью функции исходящего звука.

Получение необработанного входящего звука

Мы также можем получать примеры аудиопотока вызова как AVAudioPCMBuffer, чтобы обработать звук перед воспроизведением.

Создайте объект, указывающий RawIncomingAudioStreamOptions свойства необработанного потока, которые мы хотим получить.

    let options = RawIncomingAudioStreamOptions()
    let properties = RawIncomingAudioStreamProperties()
    properties.format = .pcm16Bit
    properties.sampleRate = .hz44100
    properties.channelMode = .stereo
    options.properties = properties

Создайте RawOutgoingAudioStream и прикрепите его к параметрам вызова для объединения.

    let options =  JoinCallOptions() // or StartCallOptions()
    let incomingAudioOptions = IncomingAudioOptions()

    self.rawIncomingStream = RawIncomingAudioStream(rawIncomingAudioStreamOptions: audioStreamOptions)
    incomingAudioOptions.stream = self.rawIncomingStream
    options.incomingAudioOptions = incomingAudioOptions

Кроме того, можно подключить поток к существующему Call экземпляру.

    call.startAudio(stream: self.rawIncomingStream) { error in 
        // Stream attached to `Call`.
    }

Для начала получения необработанного звукового буфера из входящего потока реализуется RawIncomingAudioStreamDelegate:

    class RawIncomingReceiver: NSObject, RawIncomingAudioStreamDelegate {
        func rawIncomingAudioStream(_ rawIncomingAudioStream: RawIncomingAudioStream,
                                    didChangeState args: AudioStreamStateChangedEventArgs) {
            // To be notified when stream started and stopped.
        }
        
        func rawIncomingAudioStream(_ rawIncomingAudioStream: RawIncomingAudioStream,
                                    mixedAudioBufferReceived args: IncomingMixedAudioEventArgs) {
            // Receive raw audio buffers(AVAudioPCMBuffer) and process using AVAudioEngine API's.
        }
    }

    self.rawIncomingStream.delegate = RawIncomingReceiver()

или

    rawIncomingAudioStream.events.mixedAudioBufferReceived = { args in
        // Receive raw audio buffers(AVAudioPCMBuffer) and process them using AVAudioEngine API's.
    }

    rawIncomingAudioStream.events.onStateChanged = { args in
        // To be notified when stream started and stopped.
    }

Доступ к видеоматериалам в raw-формате

Так как приложение создает видеокадры, приложение должно сообщить пакету SDK для вызовов Службы коммуникации Azure о форматах видео, которые может создать приложение. Эта информация позволяет пакету SDK для вызовов Службы коммуникации Azure выбрать лучшую конфигурацию формата видео для условий сети в то время.

Виртуальное видео

Поддерживаемые разрешения видео

1. Создайте массив VideoFormat, используя VideoStreamPixelFormat, поддерживаемый SDK. Если доступны несколько форматов, порядок форматов в списке не влияет или не определяет приоритеты используемых форматов. Критерии выбора формата основаны на внешних факторах, таких как пропускная способность сети.

   var videoStreamFormat = VideoStreamFormat()
   videoStreamFormat.resolution = VideoStreamResolution.p360
   videoStreamFormat.pixelFormat = VideoStreamPixelFormat.nv12
   videoStreamFormat.framesPerSecond = framerate
   videoStreamFormat.stride1 = w // w is the resolution width
   videoStreamFormat.stride2 = w / 2 // w is the resolution width
   
   var videoStreamFormats: [VideoStreamFormat] = [VideoStreamFormat]()
   videoStreamFormats.append(videoStreamFormat)
   

2. Создайте RawOutgoingVideoStreamOptions, и задайте форматы, используя ранее созданный объект.

   var rawOutgoingVideoStreamOptions = RawOutgoingVideoStreamOptions()
   rawOutgoingVideoStreamOptions.formats = videoStreamFormats
   

3. Создайте экземпляр VirtualOutgoingVideoStream с использованием экземпляра RawOutgoingVideoStreamOptions, созданного ранее.

   var rawOutgoingVideoStream = VirtualOutgoingVideoStream(videoStreamOptions: rawOutgoingVideoStreamOptions)
   

4. Реализуйте делегату VirtualOutgoingVideoStreamDelegate . Событие didChangeFormat сообщает, когда VideoStreamFormat изменился с одного из форматов видео, предоставленных в списке.

   virtualOutgoingVideoStream.delegate = /* Attach delegate and implement didChangeFormat */
   

5. Создание экземпляра следующего вспомогательного класса для доступа к CVPixelBuffer данным

   final class BufferExtensions: NSObject {
       public static func getArrayBuffersUnsafe(cvPixelBuffer: CVPixelBuffer) -> Array<UnsafeMutableRawPointer?>
       {
           var bufferArrayList: Array<UnsafeMutableRawPointer?> = [UnsafeMutableRawPointer?]()
   
           let cvStatus: CVReturn = CVPixelBufferLockBaseAddress(cvPixelBuffer, .readOnly)
   
           if cvStatus == kCVReturnSuccess {
               let bufferListSize = CVPixelBufferGetPlaneCount(cvPixelBuffer);
               for i in 0...bufferListSize {
                   let bufferRef = CVPixelBufferGetBaseAddressOfPlane(cvPixelBuffer, i)
                   bufferArrayList.append(bufferRef)
               }
           }
   
           return bufferArrayList
       }
   }
   

6. Создайте экземпляр следующего вспомогательного класса для генерации случайных RawVideoFrameBuffer, используя VideoStreamPixelFormat.rgba.

   final class VideoFrameSender : NSObject
   {
       private var rawOutgoingVideoStream: RawOutgoingVideoStream
       private var frameIteratorThread: Thread
       private var stopFrameIterator: Bool = false
   
       public VideoFrameSender(rawOutgoingVideoStream: RawOutgoingVideoStream)
       {
           self.rawOutgoingVideoStream = rawOutgoingVideoStream
       }
   
       @objc private func VideoFrameIterator()
       {
           while !stopFrameIterator {
               if rawOutgoingVideoStream != nil &&
                  rawOutgoingVideoStream.format != nil &&
                  rawOutgoingVideoStream.state == .started {
                   SendRandomVideoFrameNV12()
               }
          }
       }
   
       public func SendRandomVideoFrameNV12() -> Void
       {
           let videoFrameBuffer = GenerateRandomVideoFrameBuffer()
   
           rawOutgoingVideoStream.send(frame: videoFrameBuffer) { error in
               /*Handle error if non-nil*/
           }
   
           let rate = 0.1 / rawOutgoingVideoStream.format.framesPerSecond
           let second: Float = 1000000
           usleep(useconds_t(rate * second))
       }
   
       private func GenerateRandomVideoFrameBuffer() -> RawVideoFrame
       {
           var cvPixelBuffer: CVPixelBuffer? = nil
           guard CVPixelBufferCreate(kCFAllocatorDefault,
                                   rawOutgoingVideoStream.format.width,
                                   rawOutgoingVideoStream.format.height,
                                   kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
                                   nil,
                                   &cvPixelBuffer) == kCVReturnSuccess else {
               fatalError()
           }
   
           GenerateRandomVideoFrameNV12(cvPixelBuffer: cvPixelBuffer!)
   
           CVPixelBufferUnlockBaseAddress(cvPixelBuffer!, .readOnly)
   
           let videoFrameBuffer = RawVideoFrameBuffer()
           videoFrameBuffer.buffer = cvPixelBuffer!
           videoFrameBuffer.streamFormat = rawOutgoingVideoStream.format
   
           return videoFrameBuffer
       }
   
      private func GenerateRandomVideoFrameNV12(cvPixelBuffer: CVPixelBuffer) {
           let w = rawOutgoingVideoStream.format.width
           let h = rawOutgoingVideoStream.format.height
   
           let bufferArrayList = BufferExtensions.getArrayBuffersUnsafe(cvPixelBuffer: cvPixelBuffer)
   
           guard bufferArrayList.count >= 2, let yArrayBuffer = bufferArrayList[0], let uvArrayBuffer = bufferArrayList[1] else {
               return
           }
   
           let yVal = Int32.random(in: 1..<255)
           let uvVal = Int32.random(in: 1..<255)
   
           for y in 0...h
           {
               for x in 0...w
               {
                   yArrayBuffer.storeBytes(of: yVal, toByteOffset: Int((y * w) + x), as: Int32.self)
               }
           }
   
           for y in 0...(h/2)
           {
               for x in 0...(w/2)
               {
                   uvArrayBuffer.storeBytes(of: uvVal, toByteOffset: Int((y * w) + x), as: Int32.self)
               }
           }
       }
   
       public func Start() {
           stopFrameIterator = false
           frameIteratorThread = Thread(target: self, selector: #selector(VideoFrameIterator), object: "VideoFrameSender")
           frameIteratorThread?.start()
       }
   
       public func Stop() {
           if frameIteratorThread != nil {
               stopFrameIterator = true
               frameIteratorThread?.cancel()
               frameIteratorThread = nil
           }
       }
   }
   

7. Реализуйте в VirtualOutgoingVideoStreamDelegate. Событие didChangeState сообщает о состоянии текущего потока. Не отправляйте кадры, если состояние не равно VideoStreamState.started.

   /*Delegate Implementer*/ 
   private var videoFrameSender: VideoFrameSender
   func virtualOutgoingVideoStream(
       _ virtualOutgoingVideoStream: VirtualOutgoingVideoStream,
       didChangeState args: VideoStreamStateChangedEventArgs) {
       switch args.stream.state {
           case .available:
               videoFrameSender = VideoFrameSender(rawOutgoingVideoStream)
               break
           case .started:
               /* Start sending frames */
               videoFrameSender.Start()
               break
           case .stopped:
               /* Stop sending frames */
               videoFrameSender.Stop()
               break
       }
   }
   

Видео с демонстрацией экрана

Так как система Windows создает кадры, необходимо реализовать собственную службу переднего плана, чтобы записать кадры и отправить их с помощью API вызовов Службы коммуникации Azure.

Поддерживаемые разрешения видео

Действия по созданию видеопотока общего доступа к экрану

1. Создайте массив VideoFormat с использованием VideoStreamPixelFormat, который поддерживается SDK. Если доступны несколько форматов, порядок форматов в списке не влияет или не определяет приоритеты используемых форматов. Критерии выбора формата основаны на внешних факторах, таких как пропускная способность сети.

   let videoStreamFormat = VideoStreamFormat()
   videoStreamFormat.width = 1280 /* Width and height can be used for ScreenShareOutgoingVideoStream for custom resolutions or use one of the predefined values inside VideoStreamResolution */
   videoStreamFormat.height = 720
   /*videoStreamFormat.resolution = VideoStreamResolution.p360*/
   videoStreamFormat.pixelFormat = VideoStreamPixelFormat.rgba
   videoStreamFormat.framesPerSecond = framerate
   videoStreamFormat.stride1 = w * 4 /* It is times 4 because RGBA is a 32-bit format */
   
   var videoStreamFormats: [VideoStreamFormat] = []
   videoStreamFormats.append(videoStreamFormat)
   

2. Создайте RawOutgoingVideoStreamOptions, и задайте VideoFormats как созданный ранее объект.

   var rawOutgoingVideoStreamOptions = RawOutgoingVideoStreamOptions()
   rawOutgoingVideoStreamOptions.formats = videoStreamFormats
   

3. Создайте экземпляр VirtualOutgoingVideoStream, используя экземпляр RawOutgoingVideoStreamOptions, который вы создали ранее.

   var rawOutgoingVideoStream = ScreenShareOutgoingVideoStream(rawOutgoingVideoStreamOptions)
   

4. Захватите и отправьте видеокадр следующим образом.

   private func SendRawVideoFrame() -> Void
   {
       CVPixelBuffer cvPixelBuffer = /* Fill it with the content you got from the Windows APIs, The number of buffers depends on the VideoStreamPixelFormat */
       let videoFrameBuffer = RawVideoFrameBuffer()
       videoFrameBuffer.buffer = cvPixelBuffer!
       videoFrameBuffer.streamFormat = rawOutgoingVideoStream.format
   
       rawOutgoingVideoStream.send(frame: videoFrame) { error in
           /*Handle error if not nil*/
       }
   }
   

Необработанное входящее видео

Эта функция предоставляет доступ к видеокадрам внутри элементов IncomingVideoStream, чтобы управлять этими объектами потока локально.

1. Создайте экземпляр IncomingVideoOptions, который настраивается через параметр JoinCallOptions, устанавливая VideoStreamKind.RawIncoming.

   var incomingVideoOptions = IncomingVideoOptions()
   incomingVideoOptions.streamType = VideoStreamKind.rawIncoming
   var joinCallOptions = JoinCallOptions()
   joinCallOptions.incomingVideoOptions = incomingVideoOptions
   

2. После получения события ParticipantsUpdatedEventArgs прикрепите делегата RemoteParticipant.delegate.didChangedVideoStreamState. Это событие сообщает о состоянии IncomingVideoStream объектов.

   private var remoteParticipantList: [RemoteParticipant] = []
   
   func call(_ call: Call, didUpdateRemoteParticipant args: ParticipantsUpdatedEventArgs) {
       args.addedParticipants.forEach { remoteParticipant in
           remoteParticipant.incomingVideoStreams.forEach { incomingVideoStream in
               OnRawIncomingVideoStreamStateChanged(incomingVideoStream: incomingVideoStream)
           }
           remoteParticipant.delegate = /* Attach delegate OnVideoStreamStateChanged*/
       }
   
       args.removedParticipants.forEach { remoteParticipant in
           remoteParticipant.delegate = nil
       }
   }
   
   func remoteParticipant(_ remoteParticipant: RemoteParticipant, 
                          didVideoStreamStateChanged args: VideoStreamStateChangedEventArgs) {
       OnRawIncomingVideoStreamStateChanged(rawIncomingVideoStream: args.stream)
   }
   
   func OnRawIncomingVideoStreamStateChanged(rawIncomingVideoStream: RawIncomingVideoStream) {
       switch incomingVideoStream.state {
           case .available:
               /* There is a new IncomingVideoStream */
               rawIncomingVideoStream.delegate /* Attach delegate OnVideoFrameReceived*/
               rawIncomingVideoStream.start()
               break;
           case .started:
               /* Will start receiving video frames */
               break
           case .stopped:
               /* Will stop receiving video frames */
               break
           case .notAvailable:
               /* The IncomingVideoStream should not be used anymore */
               rawIncomingVideoStream.delegate = nil
               break
       }
   }
   

3. На данном этапе IncomingVideoStream имеет состояние VideoStreamState.available, к которому прикрепляется делегат RawIncomingVideoStream.delegate.didReceivedRawVideoFrame, как показано на предыдущем шаге. Это событие предоставляет новые RawVideoFrame объекты.

   func rawIncomingVideoStream(_ rawIncomingVideoStream: RawIncomingVideoStream, 
                               didRawVideoFrameReceived args: RawVideoFrameReceivedEventArgs) {
       /* Render/Modify/Save the video frame */
       let videoFrame = args.frame as! RawVideoFrameBuffer
   }
   

Быстрый старт: Испытайте тестовое приложение

• Необработанное видео

Как разработчик, вы можете получить доступ к необработанным данным для входящих и исходящих аудио, видео и данных совместного использования экрана во время звонка, чтобы записывать, анализировать и обрабатывать аудио- и видеоконтент. Доступ к клиентским данным необработанного аудио, видео и общего экрана в службах коммуникации Azure позволяет разработчикам практически неограниченно просматривать и редактировать аудио, видео и содержимое общего доступа к экрану, которое происходит в SDK для вызовов Azure Communication Services. В этом кратком руководстве вы узнаете, как реализовать необработанный доступ к мультимедиа с помощью пакета SDK для вызова Службы коммуникации Azure для JavaScript.

Например,

• Вы можете получить доступ к аудио-видеопотоку вызова непосредственно в объекте вызова и отправлять пользовательские исходящие аудио-видеопотоки во время вызова.
• Вы можете проверить звуковые и видеопотоки для запуска пользовательских моделей ИИ для анализа. Такие модели могут включать обработку естественного языка для анализа бесед или предоставления аналитических сведений и предложений в режиме реального времени для повышения производительности агента.
• Организации могут использовать потоки аудио- и видеомедийных носителей для анализа тональности при предоставлении виртуальной помощи пациентам или удаленной помощи во время видеозвонков, использующих смешанную реальность. Эта возможность открывает путь для разработчиков, которые применяют инновации для улучшения взаимодействия.

Требования

Доступ к необработанным аудио

Доступ к необработанным звуковым носителям предоставляет доступ к звуковому потоку входящих вызовов, а также возможность просматривать и отправлять пользовательские исходящие звуковые потоки во время вызова.

Доступ к входящему сырому аудиопотоку

Используйте следующий код для доступа к аудиопотоку входящего вызова.

const userId = 'acs_user_id';
const call = callAgent.startCall(userId);
const callStateChangedHandler = async () => {
    if (call.state === "Connected") {
        const remoteAudioStream = call.remoteAudioStreams[0];
        const mediaStream = await remoteAudioStream.getMediaStream();
	// process the incoming call's audio media stream track
    }
};

callStateChangedHandler();
call.on("stateChanged", callStateChangedHandler);

Совершите вызов с использованием пользовательского аудиопотока

Используйте следующий код, чтобы начать вызов с пользовательским аудиопотоком вместо использования устройства микрофона пользователя.

const createBeepAudioStreamToSend = () => {
    const context = new AudioContext();
    const dest = context.createMediaStreamDestination();
    const os = context.createOscillator();
    os.type = 'sine';
    os.frequency.value = 500;
    os.connect(dest);
    os.start();
    const { stream } = dest;
    return stream;
};

...
const userId = 'acs_user_id';
const mediaStream = createBeepAudioStreamToSend();
const localAudioStream = new LocalAudioStream(mediaStream);
const callOptions = {
    audioOptions: {
        localAudioStreams: [localAudioStream]
    }
};
callAgent.startCall(userId, callOptions);

Переключение на пользовательский аудиопоток во время вызова

Используйте следующий код, чтобы переключить устройство ввода на пользовательский аудиопоток вместо использования устройства микрофона пользователя во время вызова.

const createBeepAudioStreamToSend = () => {
    const context = new AudioContext();
    const dest = context.createMediaStreamDestination();
    const os = context.createOscillator();
    os.type = 'sine';
    os.frequency.value = 500;
    os.connect(dest);
    os.start();
    const { stream } = dest;
    return stream;
};

...

const userId = 'acs_user_id';
const mediaStream = createBeepAudioStreamToSend();
const localAudioStream = new LocalAudioStream(mediaStream);
const call = callAgent.startCall(userId);
const callStateChangedHandler = async () => {
    if (call.state === 'Connected') {
        await call.startAudio(localAudioStream);
    }
};

callStateChangedHandler();
call.on('stateChanged', callStateChangedHandler);

Остановка пользовательского аудиопотока

Используйте следующий код, чтобы остановить отправку пользовательского аудиопотока после его установки во время вызова.

call.stopAudio();

Доступ к необработанным видео

Необработанные видеоматериалы дают вам экземпляр MediaStream объекта. (Дополнительные сведения см. в документации по JavaScript.) Необработанный видеомедиатор предоставляет доступ специально к объекту MediaStream для входящих и исходящих вызовов. Для необработанного видео можно использовать этот объект для применения фильтров с помощью машинного обучения для обработки кадров видео.

Обработанные необработанные исходящие видеокадры можно отправлять в виде исходящего видео отправителя. Обработанные необработанные входящие видеокадры можно отобразить на стороне приемника.

Размещение вызова с помощью пользовательского видеопотока

Вы можете получить доступ к необработанному видеопотоку для исходящего вызова. Вы используете MediaStream исходящий необработанный видеопоток для обработки кадров с помощью машинного обучения и применения фильтров. Затем обработанный исходящий видеосигнал можно отправить как видеопоток отправителя.

В этом примере данные холста отправляются пользователю в виде исходящего видео.

const createVideoMediaStreamToSend = () => {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    canvas.width = 1500;
    canvas.height = 845;
    ctx.fillStyle = 'blue';
    ctx.fillRect(0, 0, canvas.width, canvas.height);

    const colors = ['red', 'yellow', 'green'];
    window.setInterval(() => {
        if (ctx) {
            ctx.fillStyle = colors[Math.floor(Math.random() * colors.length)];
            const x = Math.floor(Math.random() * canvas.width);
            const y = Math.floor(Math.random() * canvas.height);
            const size = 100;
            ctx.fillRect(x, y, size, size);
        }
    }, 1000 / 30);

    return canvas.captureStream(30);
};

...
const userId = 'acs_user_id';
const mediaStream = createVideoMediaStreamToSend();
const localVideoStream = new LocalVideoStream(mediaStream);
const callOptions = {
    videoOptions: {
        localVideoStreams: [localVideoStream]
    }
};
callAgent.startCall(userId, callOptions);

Переключение на пользовательскую видеотрансляцию во время вызова

Используйте следующий код, чтобы переключить устройство ввода на настраиваемый видеопоток вместо использования устройства камеры пользователя в течение звонка.

const createVideoMediaStreamToSend = () => {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    canvas.width = 1500;
    canvas.height = 845;
    ctx.fillStyle = 'blue';
    ctx.fillRect(0, 0, canvas.width, canvas.height);

    const colors = ['red', 'yellow', 'green'];
    window.setInterval(() => {
        if (ctx) {
            ctx.fillStyle = colors[Math.floor(Math.random() * colors.length)];
            const x = Math.floor(Math.random() * canvas.width);
            const y = Math.floor(Math.random() * canvas.height);
            const size = 100;
            ctx.fillRect(x, y, size, size);
	 }
    }, 1000 / 30);

    return canvas.captureStream(30);
};

...

const userId = 'acs_user_id';
const call = callAgent.startCall(userId);
const callStateChangedHandler = async () => {
    if (call.state === 'Connected') {    	
        const mediaStream = createVideoMediaStreamToSend();
        const localVideoStream = this.call.localVideoStreams.find((stream) => { return stream.mediaStreamType === 'Video' });
        await localVideoStream.setMediaStream(mediaStream);
    }
};

callStateChangedHandler();
call.on('stateChanged', callStateChangedHandler);

Остановка пользовательского видеопотока

Используйте следующий код, чтобы остановить отправку пользовательского видеопотока после его установки во время вызова.

// Stop video by passing the same `localVideoStream` instance that was used to start video
await call.stopVideo(localVideoStream);

При переключении с камеры, которая имеет настраиваемые эффекты, примененные к другому устройству камеры, сначала остановите видео, переключите источник на LocalVideoStreamи снова запустите видео.

const cameras = await this.deviceManager.getCameras();
const newCameraDeviceInfo = cameras.find(cameraDeviceInfo => { return cameraDeviceInfo.id === '<another camera that you want to switch to>' });
// If current camera is using custom raw media stream and video is on
if (this.localVideoStream.mediaStreamType === 'RawMedia' && this.state.videoOn) {
	// Stop raw custom video first
	await this.call.stopVideo(this.localVideoStream);
	// Switch the local video stream's source to the new camera to use
	this.localVideoStream?.switchSource(newCameraDeviceInfo);
	// Start video with the new camera device
	await this.call.startVideo(this.localVideoStream);

// Else if current camera is using normal stream from camera device and video is on
} else if (this.localVideoStream.mediaStreamType === 'Video' && this.state.videoOn) {
	// You can just switch the source, no need to stop and start again. Sent video will automatically switch to the new camera to use
	this.localVideoStream?.switchSource(newCameraDeviceInfo);
}

Доступ к входящему видеопотоку из удаленного участника

Вы можете получить доступ к необработанному видеопотоку для входящего вызова. MediaStream Для обработки кадров с помощью машинного обучения и применения фильтров используется входящий необработанный видеопоток. Затем обработанный входящий видеосигнал можно отобразить у получателя.

const remoteVideoStream = remoteParticipants[0].videoStreams.find((stream) => { return stream.mediaStreamType === 'Video'});
const processMediaStream = async () => {
    if (remoteVideoStream.isAvailable) {
	// remote video stream is turned on, process the video's raw media stream.
	const mediaStream = await remoteVideoStream.getMediaStream();
    } else {
	// remote video stream is turned off, handle it
    }
};

remoteVideoStream.on('isAvailableChanged', async () => {
    await processMediaStream();
});

await processMediaStream();

Доступ к функционалу «сырой» передачи экрана находится на этапе общедоступной предварительной версии и включен в версии 1.15.1-beta.1+.

Необработанный обмен экраном.

Необработанный носитель общего доступа к экрану предоставляет доступ специально к объекту MediaStream для входящих и исходящих потоков общего доступа к экрану. Для общего доступа к необработанному экрану можно использовать объект, чтобы применять фильтры с использованием машинного обучения для обработки кадров общего экрана.

Обработанные кадры общего доступа экрана можно отправлять в качестве исходящей демонстрации экрана отправителя. Обработанные кадры экранного обмена можно отрисовывать на стороне получателя.

Примечание. Отправка общего доступа к экрану поддерживается только в браузере для компьютера.

Начальный общий доступ к экрану с помощью пользовательского потока общего доступа к экрану

const createVideoMediaStreamToSend = () => {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    canvas.width = 1500;
    canvas.height = 845;
    ctx.fillStyle = 'blue';
    ctx.fillRect(0, 0, canvas.width, canvas.height);

    const colors = ['red', 'yellow', 'green'];
    window.setInterval(() => {
        if (ctx) {
            ctx.fillStyle = colors[Math.floor(Math.random() * colors.length)];
            const x = Math.floor(Math.random() * canvas.width);
            const y = Math.floor(Math.random() * canvas.height);
            const size = 100;
            ctx.fillRect(x, y, size, size);
        }
    }, 1000 / 30);

    return canvas.captureStream(30);
};

...
const mediaStream = createVideoMediaStreamToSend();
const localScreenSharingStream = new LocalVideoStream(mediaStream);
// Will start screen sharing with custom raw media stream
await call.startScreenSharing(localScreenSharingStream);
console.log(localScreenSharingStream.mediaStreamType) // 'RawMedia'

Доступ к необработанному потоку экрана, вкладки браузера или приложения и применение эффектов к этому потоку.

Ниже приведен пример того, как применить черно-белый эффект к потоку передачи необработанного изображения экрана, вкладки браузера или приложения. ПРИМЕЧАНИЕ. Фильтр контекста холста = API "серое масштабирование(1)" не поддерживается в Safari.

let bwTimeout;
let bwVideoElem;

const applyBlackAndWhiteEffect = function (stream) {
	let width = 1280, height = 720;
	bwVideoElem = document.createElement("video");
	bwVideoElem.srcObject = stream;
	bwVideoElem.height = height;
	bwVideoElem.width = width;
	bwVideoElem.play();
	const canvas = document.createElement('canvas');
	const bwCtx = canvas.getContext('2d', { willReadFrequently: true });
	canvas.width = width;
	canvas.height = height;
	
	const FPS = 30;
	const processVideo = function () {
	    try {
		let begin = Date.now();
		// start processing.
		// NOTE: The Canvas context filter API is not supported in Safari
		bwCtx.filter = "grayscale(1)";
		bwCtx.drawImage(bwVideoElem, 0, 0, width, height);
		const imageData = bwCtx.getImageData(0, 0, width, height);
		bwCtx.putImageData(imageData, 0, 0);
		// schedule the next one.
		let delay = Math.abs(1000/FPS - (Date.now() - begin));
		bwTimeout = setTimeout(processVideo, delay);
	    } catch (err) {
		console.error(err);
	    }
	}
	
	// schedule the first one.
	bwTimeout = setTimeout(processVideo, 0);
	return canvas.captureStream(FPS);
}

// Call startScreenSharing API without passing any stream parameter. Browser will prompt the user to select the screen, browser tab, or app to share in the call.
await call.startScreenSharing();
const localScreenSharingStream = call.localVideoStreams.find( (stream) => { return stream.mediaStreamType === 'ScreenSharing' });
console.log(localScreenSharingStream.mediaStreamType); // 'ScreenSharing'
// Get the raw media stream from the screen, browser tab, or application
const rawMediaStream = await localScreenSharingStream.getMediaStream();
// Apply effects to the media stream as you wish
const blackAndWhiteMediaStream = applyBlackAndWhiteEffect(rawMediaStream);
// Set the media stream with effects no the local screen sharing stream
await localScreenSharingStream.setMediaStream(blackAndWhiteMediaStream);

// Stop screen sharing and clean up the black and white video filter
await call.stopScreenSharing();
clearTimeout(bwTimeout);
bwVideoElem.srcObject.getVideoTracks().forEach((track) => { track.stop(); });
bwVideoElem.srcObject = null;

Прекратите отправку трансляции экрана

Используйте следующий код, чтобы остановить отправку пользовательского потока общего ресурса экрана после его установки во время вызова.

// Stop sending raw screen sharing stream
await call.stopScreenSharing(localScreenSharingStream);

Получение доступа к входящему потоку общего экрана от удаленного участника

Вы можете получить доступ к потоку общего доступа к необработанным экранам из удаленного участника. MediaStream Для обработки кадров с помощью машинного обучения и применения фильтров используется входящий поток общего доступа к необработанным экранам. Затем обработанный входящий поток демонстрации экрана можно отобразить на стороне получателя.

const remoteScreenSharingStream = remoteParticipants[0].videoStreams.find((stream) => { return stream.mediaStreamType === 'ScreenSharing'});
const processMediaStream = async () => {
    if (remoteScreenSharingStream.isAvailable) {
	// remote screen sharing stream is turned on, process the stream's raw media stream.
	const mediaStream = await remoteScreenSharingStream.getMediaStream();
    } else {
	// remote video stream is turned off, handle it
    }
};

remoteScreenSharingStream.on('isAvailableChanged', async () => {
    await processMediaStream();
});

await processMediaStream();