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;
}
