/// <summary> /// Reads the next packet from this file and sends it to the packet queue. /// </summary> /// <returns>Type of the readed packet.</returns> public MediaType ReadPacket() { var packet = MediaPacket.AllocateEmpty(0); var result = ffmpeg.av_read_frame(Pointer, packet.Pointer); if (result == ffmpeg.AVERROR_EOF) { IsAtEndOfFile = true; return(MediaType.None); } else { result.ThrowIfError("Cannot read next packet from the file"); } IsAtEndOfFile = false; return(EnqueuePacket(packet)); }
/// <summary> /// Reads the next packet from this file and sends it to the packet queue. /// </summary> /// <returns>Type of the readed packet.</returns> public MediaType ReadPacket() { var packet = MediaPacket.AllocateEmpty(0); var result = ffmpeg.av_read_frame(Pointer, packet.Pointer); // Gets the next packet from the file. // Check if the end of file error ocurred if (result == ffmpeg.AVERROR_EOF) { IsAtEndOfFile = true; return(MediaType.None); } else { result.ThrowIfError("Cannot read next packet from the file"); } IsAtEndOfFile = false; return(EnqueuePacket(packet)); // Sends packet to the internal decoder queue. }
/// <summary> /// Adds the packet to the internal queue of the codec. /// </summary> /// <param name="packet">The packet to be encoded or decoded.</param> /// <exception cref="ArgumentNullException"><paramref name="packet"/> is null.</exception> /// <exception cref="InvalidOperationException">The current codec is not prepared yet.</exception> /// <remarks>Any attempts to modify the packet will fail until the <see cref="InputProcessed"/> event for the packet is invoked.</remarks> /// <since_tizen> 3 </since_tizen> public void ProcessInput(MediaPacket packet) { ValidateNotDisposed(); if (packet == null) { throw new ArgumentNullException(nameof(packet)); } MediaPacket.Lock packetLock = MediaPacket.Lock.Get(packet); int ret = Interop.MediaCodec.Process(_handle, packetLock.GetHandle(), 0); if (ret == (int)MediaCodecErrorCode.InvalidState) { throw new InvalidOperationException("The codec is in invalid state."); } MultimediaDebug.AssertNoError(ret); }
internal async Task <MediaPacket> RunAsync(TransformHandle handle, MediaPacket source) { Debug.Assert(source.Format is VideoMediaFormat); ValidateFormat(source.Format as VideoMediaFormat); var tcs = new TaskCompletionSource <MediaPacket>(); using (var cbKeeper = ObjectKeeper.Get(GetCallback(tcs, source))) { var result = NativeTransform.Run(handle, source.GetHandle(), cbKeeper.Target); if (result == ImageUtilError.NotSupportedFormat) { throw new NotSupportedException( GenerateNotSupportedErrorMessage(source.Format as VideoMediaFormat)); } result.ThrowIfFailed("Failed to transform given packet with " + GetType()); return(await tcs.Task); } }
internal override async Task <MediaPacket> ApplyAsync(MediaPacket source) { using (TransformHandle handle = CreateHandle()) { if (Flip.HasFlag(Flips.Vertical | Flips.Horizontal)) { var flipped = await ApplyAsync(handle, source, ImageRotation.FlipHorizontal); try { return(await ApplyAsync(handle, flipped, ImageRotation.FlipVertical)); } finally { flipped.Dispose(); } } return(await ApplyAsync(handle, source, Flip.HasFlag(Flips.Horizontal)? ImageRotation.FlipHorizontal : ImageRotation.FlipVertical)); } }
private void RegisterInputProcessed() { _inputBufferUsedCb = (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; } Debug.Assert(packet != null); InputProcessed?.Invoke(this, new InputProcessedEventArgs(packet)); }; Native.SetInputBufferUsedCb(_handle, _inputBufferUsedCb). ThrowIfFailed("Failed to set input buffer used callback."); }
private void RegisterInputProcessed() { _inputBufferUsedCb = (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; } Debug.Assert(packet != null); InputProcessed?.Invoke(this, new InputProcessedEventArgs(packet)); }; int ret = Interop.MediaCodec.SetInputBufferUsedCb(_handle, _inputBufferUsedCb); MultimediaDebug.AssertNoError(ret); }
/// <summary> /// Transforms an image with <see cref="ImageTransform"/>. /// </summary> /// <param name="source"><see cref="MediaPacket"/> to transform. The <see cref="MediaPacket.Format"/> of this <paramref name="source"/> must be <see cref="VideoMediaFormat"/>.</param> /// <param name="item"><see cref="ImageTransform"/> to apply.</param> /// <returns>A task that represents the asynchronous transforming operation.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is null.<br/> /// -or-<br/> /// <paramref name="item"/> is null. /// </exception> /// <exception cref="ArgumentException"><paramref name="source"/> is not video format.</exception> /// <exception cref="ObjectDisposedException">The <see cref="ImageTransformer"/> has already been disposed of.</exception> /// <exception cref="InvalidOperationException">Failed to apply <see cref="ImageTransform"/>.</exception> /// <exception cref="NotSupportedException">Specified transformation is not supported.</exception> /// <since_tizen> 4 </since_tizen> public Task <MediaPacket> TransformAsync(MediaPacket source, ImageTransform item) { if (_disposed) { throw new ObjectDisposedException(nameof(ImageTransformer)); } if (source == null) { throw new ArgumentNullException(nameof(source)); } if (item == null) { throw new ArgumentNullException(nameof(item)); } if (source.Format is VideoMediaFormat == false) { throw new ArgumentException("source is not video format.", nameof(source)); } return(item.ApplyAsync(source)); }
private async Task <MediaPacket> ApplyAsync(TransformHandle handle, MediaPacket source, ImageRotation rotation) { SetRotation(handle, rotation); return(await RunAsync(handle, source)); }
internal OutputAvailableEventArgs(IntPtr packetHandle) { Packet = MediaPacket.From(packetHandle); }
/// <summary> /// Initializes a new instance of the <see cref="OutputStream{TFrame}"/> class. /// </summary> /// <param name="stream">The multimedia stream.</param> /// <param name="owner">The container that owns the stream.</param> public OutputStream(AVStream *stream, OutputContainer owner) : base(stream) { OwnerFile = owner; packet = MediaPacket.AllocateEmpty(); }
internal WebRTCFrameEncodedEventArgs(MediaStreamTrack track, MediaPacket packet) { MediaStreamTrack = track; Packet = packet; }
private void RegisterVideoFrameEncodedCallback() { _webRtcVideoFrameEncodedCallback = (handle, type, id, packet, _) => { Log.Info(WebRTCLog.Tag, $"Track type[{type}], id[{id}]"); _videoFrameEncoded?.Invoke(this, new WebRTCFrameEncodedEventArgs(new MediaStreamTrack(this, type, id), MediaPacket.From(packet))); }; NativeWebRTC.SetVideoFrameEncodedCb(Handle, _webRtcVideoFrameEncodedCallback). ThrowIfFailed("Failed to set video frame encoded callback."); }
/// <summary> /// Adds the specified packet to the codec buffer. /// </summary> /// <param name="packet">The packet to be buffered.</param> public void BufferPacket(MediaPacket packet) { BufferedPackets.Enqueue(packet); }
private InputContainer(AVFormatContext *formatContext, bool useCustomAvioContext) : base(formatContext) { packet = MediaPacket.AllocateEmpty(0); avioContextDisposingRequired = useCustomAvioContext; }
/// <summary> /// Initializes a new instance of the <see cref="MediaVisionSource"/> class based on the <see cref="MediaPacket"/>. /// </summary> /// <param name="mediaPacket">The <see cref="MediaPacket"/> from which the source will be filled.</param> /// <exception cref="NotSupportedException">None of the related features are not supported.</exception> /// <exception cref="ArgumentNullException"><paramref name="mediaPacket"/> is null.</exception> /// <exception cref="ObjectDisposedException"><paramref name="mediaPacket"/> has already been disposed of.</exception> /// <since_tizen> 4 </since_tizen> public MediaVisionSource(MediaPacket mediaPacket) : this(handle => FillMediaPacket(handle, mediaPacket)) { }
/// <summary> /// Initializes a new instance of the InputProcessedEventArgs class. /// </summary> /// <param name="packet">The packet that the codec has processed.</param> internal InputProcessedEventArgs(MediaPacket packet) { Debug.Assert(packet != null); Packet = packet; }