Azure communication service iOS screensharing

Hi @Payal Tiwari

Looks like the buffer size issue happens due to sending high-res frames too frequently. Try resizing the CVPixelBuffer and throttling the frame rate before passing it to ACSOutgoingVideoStream, this should help avoid the crash.

Hi @Payal Tiwari

Also, check if the CVPixelBuffer format matches ACS requirements, converting it to a compatible format like kCVPixelFormatType_420YpCbCr8BiPlanarFullRange can help avoid unexpected errors.

Hello ,

Thank you for your response.

I have tried multiple formats but not able to find proper stream format can you guide me for this below code how to handle valid format

below is code format .

 func`` ``loadPixelBuffer``() -> CVPixelBuffer? {

        guard let sharedContainer = FileManager.``default``.``containerURL``(``forSecurityApplicationGroupIdentifier``: "group.com.appname") else {

            print(``"❌ Error: Could not access shared container."``)

            return`` ``nil

        ``}

        let`` metadataFileURL = sharedContainer.``appendingPathComponent``(``"metadata.txt"``)

        let`` fileURL = sharedContainer.``appendingPathComponent``(``"pixelBuffer.dat"``)

        do`` {

            let`` data = ``try`` ``Data``(``contentsOf``: fileURL)

//``            ``let width = 720``  ``// Set based on actual stream size

//``            ``let height = 1280

            let`` metadata = ``try`` ``String``(``contentsOf``: metadataFileURL, ``encoding``: .``utf8``)

            let`` components = metadata.``split``(``separator``: ``"x"``).``map`` { ``Int``($0) }

            let`` width = components[``0``] ?? ``720

            let`` height = components[``1``] ?? ``1280

    

            var`` pixelBuffer: CVPixelBuffer?

            let`` attributes: [``String``: ``Any``] = [

                kCVPixelBufferWidthKey`` ``as`` ``String``: width,

                kCVPixelBufferHeightKey`` ``as`` ``String``: height,

                ``kCVPixelBufferPixelFormatTypeKey`` as String: ``kCVPixelFormatType_420YpCbCr8BiPlanarFullRange``,

                ``kCVPixelBufferIOSurfacePropertiesKey`` as String: [:]

            ``]

            let status = ``CVPixelBufferCreate``(``kCFAllocatorDefault``, width, height, ``kCVPixelFormatType_420YpCbCr8BiPlanarFullRange``, attributes as CFDictionary, &pixelBuffer)

            guard`` status == ``kCVReturnSuccess``, ``let`` pixelBuffer = pixelBuffer ``else`` {

                print(``"❌ Error: Failed to create pixel buffer."``)

                return`` ``nil

            ``}

            ``CVPixelBufferLockBaseAddress``(pixelBuffer, CVPixelBufferLockFlags(``rawValue``: 0))

            defer { ``CVPixelBufferUnlockBaseAddress``(pixelBuffer, CVPixelBufferLockFlags(``rawValue``: 0)) }

            let`` yPlane = ``CVPixelBufferGetBaseAddressOfPlane``(pixelBuffer, ``0``)

            let`` uvPlane = ``CVPixelBufferGetBaseAddressOfPlane``(pixelBuffer, ``1``)

            let`` ySize = width * height

            let`` uvSize = width * height / ``2

                ``// Ensure we have enough data to fill both planes

            guard`` data.``count`` >= (ySize + uvSize) ``else`` {

                print(``"❌ Error: Not enough data to fill Y and UV planes."``)

                return`` ``nil

            ``}

                ``// Copy Y plane (Luminance)

            if`` ``let`` yPlane = yPlane {

                ``data.``copyBytes``(``to``: yPlane.``assumingMemoryBound``(``to``: ``UInt8``.``self``), ``from``: ``0``..<ySize)

            ``}

                ``// Copy UV plane (Chrominance)

            if`` ``let`` uvPlane = uvPlane {

                ``data.``copyBytes``(``to``: uvPlane.``assumingMemoryBound``(``to``: ``UInt8``.``self``), ``from``: ySize..<(ySize + uvSize))

            ``}

            return`` pixelBuffer

        ``} ``catch`` {

            print(``"❌ Error reading pixel buffer data: ``\(error)``"``)

            return`` ``nil

        ``}

    ``}

 format.pixelFormat = VideoStreamPixelFormat.nv12

private`` ``func`` ``SendRawVideoFramePixel``(``_`` pixelBuffer : CVPixelBuffer)->``Void``{

            ``// Lock Pixel Buffer

        guard`` ``let`` buffer = ``self``.``loadPixelBuffer``() ``else`` {

            print(``"❌ Failed to load pixel buffer."``)

            return

        ``}

        let format = self.``CreateVideoStreamFormat``()

        if`` format != ``nil

        ``{

        let`` width = ``CVPixelBufferGetWidth``(pixelBuffer)

        let`` height = ``CVPixelBufferGetHeight``(pixelBuffer)

        let`` bytesPerRow = ``CVPixelBufferGetBytesPerRow``(pixelBuffer)

        let`` rawVideoFrameBuffer = RawVideoFrameBuffer()

        ``rawVideoFrameBuffer.``buffer`` = buffer

        ``format.``width`` = ``Int32``(width)

        ``format.``height`` = ``Int32``(height)

        ``format.stride1 = ``Int32``(bytesPerRow)

        ``format.stride2 =``  Int32``(bytesPerRow)

        ``format.``pixelFormat`` = .rgba

        ``rawVideoFrameBuffer.streamFormat = format

        if ``screenShareOutgoingVideoStream``?.state != .started {

            print(``"❌ Outgoing video stream is not started yet. Retrying in 1 second..."``)

            return

        ``}

        screenShareOutgoingVideoStream``?.send(frame: rawVideoFrameBuffer) { error ``in

            if`` ``let`` error = error {

                print``(``"❌ Error sending frame: ``\(error.``localizedDescription``)``"``)

            ``} ``else`` {

                print(``"✅ Frame sent successfully!"``)

            ``}

        ``}

        ``}

    ``}

Hi @Payal Tiwari

Ensure format.pixelFormat matches CVPixelBuffer format (e.g., .nv12 for kCVPixelFormatType_420YpCbCr8BiPlanarFullRange). Also, verify stride2 calculation, it may need bytesPerRow / 2 for NV12.