private void RegisterMediaPacketPreviewCallback() { _mediaPacketPreviewCallback = (IntPtr mediaPacket, IntPtr userData) => { MediaPacket packet = MediaPacket.From(mediaPacket); var eventHandler = _mediaPacketPreview; if (eventHandler != null) { eventHandler.Invoke(this, new MediaPacketPreviewEventArgs(packet)); } else { packet.Dispose(); } }; CameraErrorFactory.ThrowIfError(Native.SetMediaPacketPreviewCallback(_handle, _mediaPacketPreviewCallback, IntPtr.Zero), "Setting media packet preview callback failed"); }
private void RegisterMediaPacketPreviewCallback() { _mediaPacketPreviewCallback = (mediaPacket, _) => { MediaPacket packet = MediaPacket.From(mediaPacket); var eventHandler = _mediaPacketPreview; if (eventHandler != null) { eventHandler.Invoke(this, new MediaPacketPreviewEventArgs(packet)); } packet.Dispose(); }; Native.SetMediaPacketPreviewCallback(_handle, _mediaPacketPreviewCallback). ThrowIfFailed("Failed to set media packet preview callback."); }
private void RegisterVideoFrameDecodedCallback() { _videoFrameDecodedCallback = (packetHandle, _) => { var handler = _videoFrameDecoded; if (handler != null) { Log.Debug(PlayerLog.Tag, "packet : " + packetHandle); handler.Invoke(this, new VideoFrameDecodedEventArgs(MediaPacket.From(packetHandle))); } else { MediaPacket.From(packetHandle).Dispose(); } }; NativePlayer.SetVideoFrameDecodedCb(Handle, _videoFrameDecodedCallback). ThrowIfFailed(this, "Failed to register the VideoFrameDecoded"); }
private void RegisterBufferConsumedEvent() { _bufferConsumedCallback = (lockedPacketHandle, _) => { MediaPacket packet = null; // Lock must be disposed here, note that the packet won't be disposed. using (MediaPacket.Lock packetLock = MediaPacket.Lock.FromHandle(lockedPacketHandle)) { Debug.Assert(packetLock != null); packet = packetLock.MediaPacket; } BufferConsumed?.Invoke(this, new StreamRecorderBufferConsumedEventArgs(packet)); }; Native.SetBufferConsumedCallback(_handle, _bufferConsumedCallback). ThrowIfError("Failed to initialize buffer consumed event."); }
/// <summary> /// Pushes a packet as recording raw data. /// </summary> /// <param name="packet">An audio or video packet to record.</param> /// <remarks> /// The recorder state must be <see cref="RecorderState.Recording"/> state by <see cref="Start"/>. /// </remarks> /// <exception cref="InvalidOperationException"> /// The recorder is not in the valid state.<br/> /// -or-<br/> /// <paramref name="packet"/> is an audio packet but audio recording is not enabled(See <see cref="StreamRecorderOptions.Audio"/>).<br/> /// -or-<br/> /// <paramref name="packet"/> is a video packet but video recording is not enabled(See <see cref="StreamRecorderOptions.Video"/>).<br/> /// -or-<br/> /// <paramref name="packet"/> is a video packet but the <see cref="VideoMediaFormat.MimeType"/> does not match the video source format.<br/> /// -or-<br/> /// An internal error occurs. /// </exception> /// <exception cref="ObjectDisposedException">The <see cref="StreamRecorder"/> has already been disposed.</exception> /// <see cref="Prepare(StreamRecorderOptions)"/> /// <seealso cref="StreamRecorderOptions.Audio"/> /// <seealso cref="StreamRecorderOptions.Video"/> /// <seealso cref="StreamRecorderVideoOptions.SourceFormat"/> /// <since_tizen> 3 </since_tizen> public void PushBuffer(MediaPacket packet) { if (packet == null) { throw new ArgumentNullException(nameof(packet)); } ValidateState(RecorderState.Recording); switch (packet.Format.Type) { case MediaFormatType.Audio: if (_audioEnabled == false) { throw new InvalidOperationException("Audio option is not set."); } break; case MediaFormatType.Video: if (_videoEnabled == false) { throw new InvalidOperationException("Video option is not set."); } if (AreVideoTypesMatched(_sourceFormat, (packet.Format as VideoMediaFormat).MimeType) == false) { throw new InvalidOperationException("Video format does not match."); } break; default: throw new ArgumentException("Packet is not valid."); } Native.PushStreamBuffer(Handle, MediaPacket.Lock.Get(packet).GetHandle()) .ThrowIfError("Failed to push buffer."); }
/// <summary> /// Enable to decode an audio data for exporting PCM from a data. /// </summary> /// <param name="format">The media format handle required to audio PCM specification. /// The format has to include <see cref="AudioMediaFormat.MimeType"/>, /// <see cref="AudioMediaFormat.Channel"/> and <see cref="AudioMediaFormat.SampleRate"/>. /// If the format is NULL, the original PCM format or platform default PCM format will be applied.</param> /// <param name="option">The audio extract option.</param> /// <remarks><para>The player must be in the <see cref="PlayerState.Idle"/> state.</para> /// <para>A <see cref="AudioDataDecoded"/> event is called in a separate thread(not in the main loop).</para> /// <para>The audio PCM data can be retrieved using a <see cref="AudioDataDecoded"/> event as a media packet /// and it is available until it's destroyed by <see cref="MediaPacket.Dispose()"/>. /// The packet has to be destroyed as quickly as possible after rendering the data /// and all the packets have to be destroyed before <see cref="Unprepare"/> is called.</para></remarks> /// <exception cref="ObjectDisposedException">The player has already been disposed of.</exception> /// <exception cref="ArgumentException">The value is not valid.</exception> /// <exception cref="InvalidOperationException"> /// Operation failed; internal error. /// -or-<br/> /// The player is not in the valid state. /// </exception> /// <seealso cref="PlayerAudioExtractOption"/> /// <seealso cref="DisableExportingAudioData"/> /// <since_tizen> 6 </since_tizen> public void EnableExportingAudioData(AudioMediaFormat format, PlayerAudioExtractOption option) { ValidatePlayerState(PlayerState.Idle); ValidationUtil.ValidateEnum(typeof(PlayerAudioExtractOption), option, nameof(option)); _audioFrameDecodedCallback = (IntPtr packetHandle, IntPtr userData) => { var handler = AudioDataDecoded; if (handler != null) { Log.Debug(PlayerLog.Tag, "packet : " + packetHandle.ToString()); handler.Invoke(this, new AudioDataDecodedEventArgs(MediaPacket.From(packetHandle))); } else { MediaPacket.From(packetHandle).Dispose(); } }; NativePlayer.SetAudioFrameDecodedCb(Handle, format == null ? IntPtr.Zero : format.AsNativeHandle(), option, _audioFrameDecodedCallback, IntPtr.Zero).ThrowIfFailed(this, "Failed to register the _audioFrameDecoded"); }
internal MediaPacketVideoPlane(MediaPacket packet, int index) { Debug.Assert(packet != null, "The packet is null!"); Debug.Assert(!packet.IsDisposed, "Packet is already disposed!"); Debug.Assert(index >= 0, "Video plane index must not be negative!"); _packet = packet; int ret = Interop.MediaPacket.GetVideoStrideWidth(packet.GetHandle(), index, out _strideWidth); MultimediaDebug.AssertNoError(ret); ret = Interop.MediaPacket.GetVideoStrideHeight(packet.GetHandle(), index, out _strideHeight); MultimediaDebug.AssertNoError(ret); Debug.Assert(_strideWidth >= 0 && _strideHeight >= 0, "size must not be negative!"); ret = Interop.MediaPacket.GetVideoPlaneData(packet.GetHandle(), index, out var dataHandle); MultimediaDebug.AssertNoError(ret); Debug.Assert(dataHandle != IntPtr.Zero, "Data handle is invalid!"); _buffer = new DependentMediaBuffer(packet, dataHandle, _strideWidth * _strideHeight); }
internal StreamRecorderBufferConsumedEventArgs(MediaPacket packet) { Packet = packet; }
/// <summary> /// Initializes a new instance of the AudioFrameDecodedEventArgs class. /// </summary> internal AudioDataDecodedEventArgs(MediaPacket packet) { Packet = packet; }
/// <summary> /// Initializes a new instance of the VideoFrameDecodedEventArgs class. /// </summary> internal VideoFrameDecodedEventArgs(MediaPacket packet) { Packet = packet; }
internal MediaPacketPreviewEventArgs(MediaPacket packet) { Packet = packet; }