/// <summary> /// Gets a blank video frame which can be filled with video data and passed /// to the encoder. /// </summary> /// <returns>Error code</returns> public PPError GetVideoFrame() { var OnEncoderFrameCallback = new CompletionCallbackWithOutput <PPResource>(OnVideoFrame); return((PPError)PPBVideoEncoder.GetVideoFrame(this, out OnEncoderFrameCallback.OutputAdapter.output, OnEncoderFrameCallback.Callback)); }
/// <summary> // Gets a free frame for output. The frame is allocated by // <code>Configure()</code>. The caller should fill it with frame data, and // then use |PutFrame()| to send the frame back. /// </summary> /// <returns>Error code</returns> public PPError GetEmptyFrame() { var action = new Action <PPError, PPResource>((result, resource) => { OnGetEmptyFrame(new VideoFrameInfo(result, resource)); }); var callback = new CompletionCallbackWithOutput <PPResource>(new CompletionCallbackWithOutputFunc <PPResource>(action)); return((PPError)PPBMediaStreamVideoTrack.GetEmptyFrame(this, out callback.OutputAdapter.output, callback)); }
/// <summary> /// Gets the next audio buffer from the MediaStream track. /// If internal processing is slower than the incoming buffer rate, /// new buffers will be dropped from the incoming stream. Once all buffers /// are full, audio samples will be dropped until <code>RecycleBuffer()</code> /// is called to free a spot for another buffer. /// If there are no audio data in the input buffer, /// <code>CompletionPending</code> will be returned immediately and the /// <code>HandleBuffer</code> event handler will be called when a new buffer of audio samples /// is received or some error happens. /// </summary> /// <returns>Error code</returns> public PPError GetBuffer() { var action = new Action <PPError, PPResource>( (result, resource) => { OnGetBuffer(new AudioBufferInfo(result, resource)); } ); var callback = new CompletionCallbackWithOutput <PPResource>(new CompletionCallbackWithOutputFunc <PPResource>(action)); return((PPError)PPBMediaStreamAudioTrack.GetBuffer(this, out callback.OutputAdapter.output, callback)); }
/// <summary> /// Returns objects that describe the network interfaces. /// </summary> /// <returns>Error code</returns> public PPError UpdateNetworkList() { Action <PPError, PPResource> callback = new Action <PPError, PPResource>( (result, resource) => { OnUpdateNetworkList(result, new NetworkList(resource)); } ); var onUpdateNetworkListCallback = new CompletionCallbackWithOutput <PPResource>(new CompletionCallbackWithOutputFunc <PPResource>(callback)); return((PPError)PPBNetworkMonitor.UpdateNetworkList(this, out onUpdateNetworkListCallback.OutputAdapter.output, onUpdateNetworkListCallback)); }
/// <summary> /// Retrieves the proxy that will be used for the given URL. The result will /// be a string in PAC format. For more details about PAC format, please see /// http://en.wikipedia.org/wiki/Proxy_auto-config /// </summary> /// <param name="instance">An <code>InstanceHandle</code> identifying one /// instance of a module.</param> /// <param name="url">A string containing a URL.</param> /// <returns>Error code</returns> public static PPError GetProxyForURL(Instance instance, string url) { var cbwoAction = new Action <PPError, PPVar>( (result, proxy) => { HandleProxyForUrl?.Invoke(instance, new ProxyInfo(result, ((Var)proxy).AsString())); } ); var cbwo = new CompletionCallbackWithOutput <PPVar>(new CompletionCallbackWithOutputFunc <PPVar>(cbwoAction)); return((PPError)PPBNetworkProxy.GetProxyForURL(instance, new Var(url), out cbwo.OutputAdapter.output, cbwo)); }
/// <summary> /// Read() reads from an offset in the file. A PP_ArrayOutput must be /// provided so that output will be stored in its allocated buffer. This /// function might perform a partial read. /// </summary> /// <param name="buffer">An ArraySegment<byte> to hold the specified number of bytes read.</param> /// <param name="offset">The offset into the file.</param> /// <param name="bytesToRead">The number of bytes to read from <code>offset</code>.</param> /// <returns>Error code. If the return value is 0, then end-of-file was reached.</returns> public PPError Read(ArraySegment <byte> buffer, int offset, int bytesToRead) { var readToArrayAction = new Action <PPError, byte[]>( (result, bytes) => { Array.Copy(bytes, buffer.Array, Math.Min(bytes.Length, buffer.Count)); OnReadData(result); } ); var arrayOutput = new CompletionCallbackWithOutput <byte[]>(new CompletionCallbackWithOutputFunc <byte[]>(readToArrayAction)); return((PPError)PPBFileIO.ReadToArray(this, offset, bytesToRead, ref arrayOutput.ArrayOutput, arrayOutput)); }
/// <summary> /// Gets an array of supported video encoder profiles. /// These can be used to choose a profile before calling Initialize(). /// </summary> /// <returns>If >= 0, the number of supported profiles returned, otherwise an /// error code. /// </returns> public PPError GetSupportedProfiles() { var probed = new Action <PPError, PPVideoProfileDescription01[]> ((result, profiles) => { var sv = new List <VideoProfileDescription>(); if (profiles != null) { for (int i = 0; i < profiles.Length; ++i) { sv.Add(new VideoProfileDescription(profiles[i])); } } OnEncoderProbed(result, sv.AsReadOnly()); }); var encoderProbedCallback = new CompletionCallbackWithOutput <PPVideoProfileDescription01[]>(new CompletionCallbackWithOutputFunc <PPVideoProfileDescription01[]>(probed)); return((PPError)PPBVideoEncoder.GetSupportedProfiles(this, encoderProbedCallback, encoderProbedCallback.Callback)); }
/// <summary> /// Query() queries info about the file opened by this FileIO object. This /// function will fail if the FileIO object has not been opened. /// </summary> /// <returns>Error code</returns> public PPError Query() { var ficb = new CompletionCallbackWithOutput <PPFileInfo>(OnQuery); return((PPError)PPBFileIO.Query(this, out ficb.OutputAdapter.output, ficb)); }
/// <summary> /// ReadDirectoryEntries() Reads all entries in the directory. /// </summary> /// <returns>Error code.</returns> PPError ReadDirectoryEntries() { var listCallback = new CompletionCallbackWithOutput <PPDirectoryEntry[], PPResource>(ListCallback, this); return((PPError)PPBFileRef.ReadDirectoryEntries(this, listCallback, listCallback)); }
/// <summary> /// Gets the next encoded bitstream buffer from the encoder. /// </summary> /// <returns>Returns Failed if Initialize() has not successfully completed. /// Returns InProgress if a prior call to GetBitstreamBuffer() has /// not completed.</returns> public PPError GetBitstreamBuffer() { var callback = new CompletionCallbackWithOutput <PPBitstreamBuffer>(OnBitstreamBuffer); return((PPError)PPBVideoEncoder.GetBitstreamBuffer(this, out callback.OutputAdapter.output, callback)); }