internal override void AsNativeHandle(IntPtr handle) { Debug.Assert(Type == MediaFormatType.Audio); int ret = Native.SetAudioMimeType(handle, MimeType); MultimediaDebug.AssertNoError(ret); ret = Native.SetAudioChannel(handle, Channel); MultimediaDebug.AssertNoError(ret); ret = Native.SetAudioSampleRate(handle, SampleRate); MultimediaDebug.AssertNoError(ret); ret = Native.SetAudioBit(handle, Bit); MultimediaDebug.AssertNoError(ret); ret = Native.SetAudioAverageBps(handle, BitRate); MultimediaDebug.AssertNoError(ret); ret = Native.SetAudioAacType(handle, AacType); MultimediaDebug.AssertNoError(ret); if (AudioChannelMap != null) { ret = Native.SetAudioChannelMask(handle, GetAudioChannelMask(handle, AudioChannelMap)); MultimediaDebug.AssertNoError(ret); } }
/// <summary> /// Creates a media format from a native handle. /// </summary> /// <param name="handle">A native handle.</param> /// <returns>An object of one of the subclasses of <see cref="MediaFormat"/>.</returns> internal static MediaFormat FromHandle(IntPtr handle) { if (handle == IntPtr.Zero) { throw new ArgumentException("The handle value is invalid."); } int type = 0; int ret = Interop.MediaFormat.GetType(handle, out type); if (ret != (int)ErrorCode.InvalidOperation) { MultimediaDebug.AssertNoError(ret); switch ((MediaFormatType)type) { case MediaFormatType.Container: return(new ContainerMediaFormat(handle)); case MediaFormatType.Video: return(new VideoMediaFormat(handle)); case MediaFormatType.Audio: return(new AudioMediaFormat(handle)); case MediaFormatType.Text: return(new TextMediaFormat(handle)); } } throw new ArgumentException("looks like handle is corrupted."); }
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!"); IntPtr dataHandle; ret = Interop.MediaPacket.GetVideoPlaneData(packet.GetHandle(), index, out dataHandle); MultimediaDebug.AssertNoError(ret); Debug.Assert(dataHandle != IntPtr.Zero, "Data handle is invalid!"); _buffer = new DependentMediaBuffer(packet, dataHandle, _strideWidth * _strideHeight); }
/// <summary> /// Retrieves frame rate from a native handle. /// </summary> /// <param name="handle">A native handle that the properties are retrieved from.</param> /// <param name="frameRate">An out parameter for the frame rate.</param> private static void GetFrameRate(IntPtr handle, out int frameRate) { Debug.Assert(handle != IntPtr.Zero, "The handle is invalid!"); int ret = Interop.MediaFormat.GetVideoFrameRate(handle, out frameRate); MultimediaDebug.AssertNoError(ret); }
/// <summary> /// Drains the buffered audio data from the output stream. /// It blocks the calling thread until the drain of the stream buffer is complete, for example, at the end of playback. /// </summary> /// <exception cref="ObjectDisposedException">The AudioPlayback has already been disposed of.</exception> /// <exception cref="InvalidOperationException">The current state is <see cref="AudioIOState.Idle"/>.</exception> /// <since_tizen> 3 </since_tizen> public void Drain() { ValidateState(AudioIOState.Running, AudioIOState.Paused); int ret = AudioOutput.Drain(_handle); MultimediaDebug.AssertNoError(ret); }
private AudioStreamFocusState GetFocusState(bool playback) { int ret = Interop.AudioStreamPolicy.GetFocusState(Handle, out var stateForPlayback, out var stateForRecording); MultimediaDebug.AssertNoError(ret); return(playback ? stateForPlayback : stateForRecording); }
/// <summary> /// Flushes and discards buffered audio data from the input stream. /// </summary> /// <exception cref="InvalidOperationException">The current state is <see cref="AudioIOState.Idle"/>.</exception> /// <exception cref="ObjectDisposedException">The AudioCaptureBase has already been disposed of.</exception> /// <since_tizen> 3 </since_tizen> public void Flush() { ValidateState(AudioIOState.Running, AudioIOState.Paused); int ret = AudioInput.Flush(_handle); MultimediaDebug.AssertNoError(ret); }
internal override void AsNativeHandle(IntPtr handle) { Debug.Assert(Type == MediaFormatType.Container); int ret = Interop.MediaFormat.SetContainerMimeType(handle, MimeType); MultimediaDebug.AssertNoError(ret); }
private static IntPtr GetExtra(IntPtr handle) { int ret = Interop.MediaPacket.GetExtra(handle, out var value); MultimediaDebug.AssertNoError(ret); return(value); }
private static ulong GetAudioChannelMask(IntPtr handle, IList <MediaFormatAudioChannelPosition> audioChannelMap) { int ret = Native.GetMaskFromChannelPosition(handle, audioChannelMap.ToArray(), out ulong mask); MultimediaDebug.AssertNoError(ret); return(mask); }
/// <summary> /// Creates a native media format from this object. /// </summary> /// <returns>A converted native handle.</returns> /// <remarks>The returned handle must be destroyed using <see cref="Interop.MediaFormat.Unref(IntPtr)"/>.</remarks> internal IntPtr AsNativeHandle() { int ret = Interop.MediaFormat.Create(out var handle); MultimediaDebug.AssertNoError(ret); AsNativeHandle(handle); return(handle); }
internal override void AsNativeHandle(IntPtr handle) { Debug.Assert(Type == MediaFormatType.Text); int ret = Interop.MediaFormat.SetTextMimeType(handle, (int)MimeType); MultimediaDebug.AssertNoError(ret); ret = Interop.MediaFormat.SetTextType(handle, (int)TextType); MultimediaDebug.AssertNoError(ret); }
/// <summary> /// Retrieves the AAC type value from a native handle. /// </summary> /// <param name="handle">A native handle that the properties are retrieved from.</param> private static MediaFormatAacType GetAacType(IntPtr handle) { Debug.Assert(handle != IntPtr.Zero, "The handle is invalid!"); int ret = Native.GetAudioAacType(handle, out var aacType); MultimediaDebug.AssertNoError(ret); Debug.Assert(Enum.IsDefined(typeof(MediaFormatAacType), aacType), "Invalid aac type!"); return(aacType); }
private static ReadOnlyCollection <MediaFormatAudioChannelPosition> GetAudioChannelMap(IntPtr handle) { var ret = Native.GetAudioChannelMask(handle, out ulong mask); MultimediaDebug.AssertNoError(ret); ret = Native.GetChannelPositionFromMask(handle, mask, out MediaFormatAudioChannelPosition[] positions); MultimediaDebug.AssertNoError(ret); return(positions == null ? null : new ReadOnlyCollection <MediaFormatAudioChannelPosition>(positions.Distinct().OrderBy(p => p).ToList())); }
/// <summary> /// Retrieves audio properties of the media format from a native handle. /// </summary> /// <param name="handle">A native handle that the properties are retrieved from.</param> /// <param name="mimeType">An out parameter for the mime type.</param> /// <param name="channel">An out parameter for the channel.</param> /// <param name="sampleRate">An out parameter for the sample rate.</param> /// <param name="bit">An out parameter for the bit.</param> /// <param name="bitRate">An out parameter for the bit rate.</param> private static void GetInfo(IntPtr handle, out MediaFormatAudioMimeType mimeType, out int channel, out int sampleRate, out int bit, out int bitRate) { Debug.Assert(handle != IntPtr.Zero, "The handle is invalid!"); int ret = Native.GetAudioInfo(handle, out mimeType, out channel, out sampleRate, out bit, out bitRate); MultimediaDebug.AssertNoError(ret); Debug.Assert(Enum.IsDefined(typeof(MediaFormatAudioMimeType), mimeType), "Invalid audio mime type!"); }
/// <summary> /// Retrieves the AAC type value from a native handle. /// </summary> /// <param name="handle">A native handle that the properties are retrieved from.</param> /// <param name="aacType">An out parameter for tha AAC type.</param> private static void GetAacType(IntPtr handle, out MediaFormatAacType aacType) { Debug.Assert(handle != IntPtr.Zero, "The handle is invalid!"); int aacTypeValue = 0; int ret = Interop.MediaFormat.GetAudioAacType(handle, out aacTypeValue); MultimediaDebug.AssertNoError(ret); aacType = (MediaFormatAacType)aacTypeValue; Debug.Assert(Enum.IsDefined(typeof(MediaFormatAacType), aacType), "Invalid aac type!"); }
/// <summary> /// Initializes a new instance of the ContainerMediaFormat class from a native handle. /// </summary> /// <param name="handle">A native media format handle.</param> internal ContainerMediaFormat(IntPtr handle) : base(MediaFormatType.Container) { Debug.Assert(handle != IntPtr.Zero, "The handle is invalid!"); int ret = Interop.MediaFormat.GetContainerMimeType(handle, out var mimeType); MultimediaDebug.AssertNoError(ret); Debug.Assert(Enum.IsDefined(typeof(MediaFormatContainerMimeType), mimeType), "Invalid container mime type!"); MimeType = mimeType; }
internal AudioDevice(IntPtr deviceHandle) { int ret = Interop.AudioDevice.GetDeviceId(deviceHandle, out _id); MultimediaDebug.AssertNoError(ret); ret = Interop.AudioDevice.GetDeviceName(deviceHandle, out var name); MultimediaDebug.AssertNoError(ret); Name = Marshal.PtrToStringAnsi(name); ret = Interop.AudioDevice.GetDeviceType(deviceHandle, out _type); MultimediaDebug.AssertNoError(ret); ret = Interop.AudioDevice.GetDeviceIoDirection(deviceHandle, out _ioDirection); MultimediaDebug.AssertNoError(ret); }
/// <summary> /// Initializes a new instance of the TextMediaFormat class from a native handle. /// </summary> /// <param name="handle">A native handle.</param> internal TextMediaFormat(IntPtr handle) : base(MediaFormatType.Text) { Debug.Assert(handle != IntPtr.Zero, "The handle is invalid!"); int ret = Interop.MediaFormat.GetTextInfo(handle, out var mimeType, out var textType); MultimediaDebug.AssertNoError(ret); Debug.Assert(Enum.IsDefined(typeof(MediaFormatTextMimeType), mimeType), "Invalid text mime type!"); Debug.Assert(Enum.IsDefined(typeof(MediaFormatTextType), textType), "Invalid text type!"); MimeType = mimeType; TextType = textType; }
/// <summary> /// Retrieves video planes of the current packet. /// </summary> /// <returns>The <see cref="MediaPacketVideoPlane"/>s allocated to the current MediaPacket.</returns> private MediaPacketVideoPlane[] GetVideoPlanes() { Debug.Assert(_handle != IntPtr.Zero, "The handle is invalid!"); int ret = Native.GetNumberOfVideoPlanes(_handle, out var numberOfPlanes); MultimediaDebug.AssertNoError(ret); MediaPacketVideoPlane[] planes = new MediaPacketVideoPlane[numberOfPlanes]; for (int i = 0; i < numberOfPlanes; ++i) { planes[i] = new MediaPacketVideoPlane(this, i); } return(planes); }
/// <summary> /// Retrieves video properties of the media format from a native handle. /// </summary> /// <param name="handle">A native handle that the properties are retrieved from.</param> /// <param name="width">An out parameter for the width.</param> /// <param name="height">An out parameter for the height.</param> /// <param name="bitRate">An out parameter for the bit rate.</param> /// <param name="mimeType">An out parameter for the mime type.</param> private static void GetInfo(IntPtr handle, out int width, out int height, out int bitRate, out MediaFormatVideoMimeType mimeType) { Debug.Assert(handle != IntPtr.Zero, "The handle is invalid!"); int mimeTypeValue = 0; int maxBps = 0; int ret = Interop.MediaFormat.GetVideoInfo(handle, out mimeTypeValue, out width, out height, out bitRate, out maxBps); MultimediaDebug.AssertNoError(ret); mimeType = (MediaFormatVideoMimeType)mimeTypeValue; Debug.Assert(Enum.IsDefined(typeof(MediaFormatVideoMimeType), mimeType), "Invalid video mime type!"); }
/// <summary> /// Retrieves text properties of the media format from a native handle. /// </summary> /// <param name="handle">A native handle that the properties are retrieved from.</param> /// <param name="mimeType">An out parameter for the mime type.</param> /// <param name="textType">An out parameter for the text type.</param> private static void GetInfo(IntPtr handle, out MediaFormatTextMimeType mimeType, out MediaFormatTextType textType) { int mimeTypeValue = 0; int textTypeValue = 0; int ret = Interop.MediaFormat.GetTextInfo(handle, out mimeTypeValue, out textTypeValue); MultimediaDebug.AssertNoError(ret); mimeType = (MediaFormatTextMimeType)mimeTypeValue; textType = (MediaFormatTextType)textTypeValue; Debug.Assert(Enum.IsDefined(typeof(MediaFormatTextMimeType), mimeType), "Invalid text mime type!"); Debug.Assert(Enum.IsDefined(typeof(MediaFormatTextType), textType), "Invalid text type!"); }
/// <summary> /// Retrieves the buffer of the current packet. /// </summary> /// <returns>The <see cref="IMediaBuffer"/> allocated to the current MediaPacket.</returns> private IMediaBuffer GetBuffer() { Debug.Assert(!IsDisposed, "Packet is already disposed!"); Debug.Assert(_handle != IntPtr.Zero, "The handle is invalid!"); int ret = Native.GetBufferData(_handle, out var dataHandle); MultimediaDebug.AssertNoError(ret); Debug.Assert(dataHandle != IntPtr.Zero, "Data handle is invalid!"); ret = Native.GetAllocatedBufferSize(_handle, out var size); MultimediaDebug.AssertNoError(ret); Debug.Assert(size >= 0, "size must not be negative!"); return(new DependentMediaBuffer(this, dataHandle, size)); }
internal override void AsNativeHandle(IntPtr handle) { Debug.Assert(Type == MediaFormatType.Video); int ret = Interop.MediaFormat.SetVideoMimeType(handle, (int)MimeType); MultimediaDebug.AssertNoError(ret); ret = Interop.MediaFormat.SetVideoWidth(handle, Size.Width); MultimediaDebug.AssertNoError(ret); ret = Interop.MediaFormat.SetVideoHeight(handle, Size.Height); MultimediaDebug.AssertNoError(ret); ret = Interop.MediaFormat.SetVideoAverageBps(handle, BitRate); MultimediaDebug.AssertNoError(ret); ret = Interop.MediaFormat.SetVideoFrameRate(handle, FrameRate); MultimediaDebug.AssertNoError(ret); }
/// <summary> /// Initializes a new instance of the MediaPacket class from a native handle. /// </summary> /// <param name="handle">The native handle to be used.</param> internal MediaPacket(IntPtr handle) { _handle = handle; int ret = Native.GetFormat(handle, out IntPtr formatHandle); MultimediaDebug.AssertNoError(ret); try { if (formatHandle != IntPtr.Zero) { _format = MediaFormat.FromHandle(formatHandle); } } finally { NativeFormat.Unref(formatHandle); } }
/// <summary> /// Creates and initializes a native handle for the current object. /// </summary> /// <param name="format">The format to be set to the media format.</param> /// <exception cref="InvalidOperationException">Operation failed.</exception> private void Initialize(MediaFormat format) { if (format.Type == MediaFormatType.Container) { throw new ArgumentException("Container format can't be used to create a new packet.", nameof(format)); } IntPtr formatHandle = IntPtr.Zero; try { formatHandle = format.AsNativeHandle(); int ret = Native.Create(formatHandle, IntPtr.Zero, IntPtr.Zero, out _handle); MultimediaDebug.AssertNoError(ret); Debug.Assert(_handle != IntPtr.Zero, "Created handle must not be null"); Alloc(); } catch (Exception) { if (_handle != IntPtr.Zero) { Native.Destroy(_handle); _handle = IntPtr.Zero; } throw; } finally { if (formatHandle != IntPtr.Zero) { NativeFormat.Unref(formatHandle); } } }
/// <summary> /// Initializes a new instance of the VideoMediaForma class from a native handle. /// </summary> /// <param name="handle">A native handle.</param> internal VideoMediaFormat(IntPtr handle) : base(MediaFormatType.Video) { Debug.Assert(handle != IntPtr.Zero, "The handle is invalid!"); int ret = Interop.MediaFormat.GetVideoInfo(handle, out var mimeType, out var width, out var height, out var bitRate, out var maxBps); MultimediaDebug.AssertNoError(ret); Debug.Assert(Enum.IsDefined(typeof(MediaFormatVideoMimeType), mimeType), "Invalid video mime type!"); ret = Interop.MediaFormat.GetVideoFrameRate(handle, out var frameRate); MultimediaDebug.AssertNoError(ret); MimeType = mimeType; Size = new Size(width, height); FrameRate = frameRate; BitRate = bitRate; }
/// <summary> /// Creates and initializes a native handle for the current object. /// </summary> /// <param name="format">The format to be set to the media format.</param> /// <exception cref="InvalidOperationException">Operation failed.</exception> private void Initialize(MediaFormat format) { if (format.Type == MediaFormatType.Container) { throw new ArgumentException("Creating a packet for container is not supported."); } IntPtr formatHandle = IntPtr.Zero; try { formatHandle = format.AsNativeHandle(); int ret = Interop.MediaPacket.Create(formatHandle, IntPtr.Zero, IntPtr.Zero, out _handle); MultimediaDebug.AssertNoError(ret); Debug.Assert(_handle != IntPtr.Zero, "Created handle must not be null"); Alloc(); } catch (Exception) { if (_handle != IntPtr.Zero) { Interop.MediaPacket.Destroy(_handle); _handle = IntPtr.Zero; } throw; } finally { if (formatHandle != IntPtr.Zero) { Interop.MediaFormat.Unref(formatHandle); } } }
internal override void AsNativeHandle(IntPtr handle) { Debug.Assert(Type == MediaFormatType.Audio); int ret = Interop.MediaFormat.SetAudioMimeType(handle, (int)MimeType); MultimediaDebug.AssertNoError(ret); ret = Interop.MediaFormat.SetAudioChannel(handle, Channel); MultimediaDebug.AssertNoError(ret); ret = Interop.MediaFormat.SetAudioSampleRate(handle, SampleRate); MultimediaDebug.AssertNoError(ret); ret = Interop.MediaFormat.SetAudioBit(handle, Bit); MultimediaDebug.AssertNoError(ret); ret = Interop.MediaFormat.SetAudioAverageBps(handle, BitRate); MultimediaDebug.AssertNoError(ret); ret = Interop.MediaFormat.SetAudioAacType(handle, (int)AacType); MultimediaDebug.AssertNoError(ret); }
private void SetExtra(IntPtr ptr) { int ret = Interop.MediaPacket.SetExtra(_packet._handle, ptr); MultimediaDebug.AssertNoError(ret); }