diff options
author | Allan Sandfeld Jensen <allan.jensen@theqtcompany.com> | 2015-06-18 14:10:49 +0200 |
---|---|---|
committer | Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com> | 2015-06-18 13:53:24 +0000 |
commit | 813fbf95af77a531c57a8c497345ad2c61d475b3 (patch) | |
tree | 821b2c8de8365f21b6c9ba17a236fb3006a1d506 /chromium/ppapi/cpp/video_encoder.h | |
parent | af6588f8d723931a298c995fa97259bb7f7deb55 (diff) | |
download | qtwebengine-chromium-813fbf95af77a531c57a8c497345ad2c61d475b3.tar.gz |
BASELINE: Update chromium to 44.0.2403.47
Change-Id: Ie056fedba95cf5e5c76b30c4b2c80fca4764aa2f
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>
Diffstat (limited to 'chromium/ppapi/cpp/video_encoder.h')
-rw-r--r-- | chromium/ppapi/cpp/video_encoder.h | 179 |
1 files changed, 179 insertions, 0 deletions
diff --git a/chromium/ppapi/cpp/video_encoder.h b/chromium/ppapi/cpp/video_encoder.h new file mode 100644 index 00000000000..44160d90168 --- /dev/null +++ b/chromium/ppapi/cpp/video_encoder.h @@ -0,0 +1,179 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef PPAPI_CPP_VIDEO_ENCODER_H_ +#define PPAPI_CPP_VIDEO_ENCODER_H_ + +#include "ppapi/c/pp_codecs.h" +#include "ppapi/c/pp_size.h" +#include "ppapi/cpp/completion_callback.h" +#include "ppapi/cpp/resource.h" +#include "ppapi/cpp/size.h" +#include "ppapi/cpp/video_frame.h" + +/// @file +/// This file defines the API to create and use a VideoEncoder resource. + +namespace pp { + +class InstanceHandle; + +/// Video encoder interface. +/// +/// Typical usage: +/// - Call Create() to create a new video encoder resource. +/// - Call GetSupportedFormats() to determine which codecs and profiles are +/// available. +/// - Call Initialize() to initialize the encoder for a supported profile. +/// - Call GetVideoFrame() to get a blank frame and fill it in, or get a video +/// frame from another resource, e.g. <code>PPB_MediaStreamVideoTrack</code>. +/// - Call Encode() to push the video frame to the encoder. If an external frame +/// is pushed, wait for completion to recycle the frame. +/// - Call GetBitstreamBuffer() continuously (waiting for each previous call to +/// complete) to pull encoded pictures from the encoder. +/// - Call RecycleBitstreamBuffer() after consuming the data in the bitstream +/// buffer. +/// - To destroy the encoder, the plugin should release all of its references to +/// it. Any pending callbacks will abort before the encoder is destroyed. +/// +/// Available video codecs vary by platform. +/// All: theora, vorbis, vp8. +/// Chrome and ChromeOS: h264. +/// ChromeOS: mpeg4. +class VideoEncoder : public Resource { + public: + /// Default constructor for creating an is_null() <code>VideoEncoder</code> + /// object. + VideoEncoder(); + + /// A constructor used to create a <code>VideoEncoder</code> and associate it + /// with the provided <code>Instance</code>. + /// @param[in] instance The instance with which this resource will be + /// associated. + explicit VideoEncoder(const InstanceHandle& instance); + + /// The copy constructor for <code>VideoEncoder</code>. + /// @param[in] other A reference to a <code>VideoEncoder</code>. + VideoEncoder(const VideoEncoder& other); + + /// Gets an array of supported video encoder profiles. + /// These can be used to choose a profile before calling Initialize(). + /// + /// @param[in] callback A <code>CompletionCallbackWithOutput</code> to be + /// called upon completion with the PP_VideoProfileDescription structs. + /// + /// @return If >= 0, the number of supported profiles returned, otherwise an + /// error code from <code>pp_errors.h</code>. + int32_t GetSupportedProfiles(const CompletionCallbackWithOutput< + std::vector<PP_VideoProfileDescription> >& cc); + + /// Initializes a video encoder resource. This should be called after + /// GetSupportedProfiles() and before any functions below. + /// + /// @param[in] input_format The <code>PP_VideoFrame_Format</code> of the + /// frames which will be encoded. + /// @param[in] input_visible_size A <code>Size</code> specifying the + /// dimensions of the visible part of the input frames. + /// @param[in] output_profile A <code>PP_VideoProfile</code> specifying the + /// codec profile of the encoded output stream. + /// @param[in] acceleration A <code>PP_HardwareAcceleration</code> specifying + /// whether to use a hardware accelerated or a software implementation. + /// @param[in] callback A <code>CompletionCallback</code> to be called upon + /// completion. + /// + /// @return An int32_t containing an error code from <code>pp_errors.h</code>. + /// Returns PP_ERROR_NOTSUPPORTED if video encoding is not available, or the + /// requested codec profile is not supported. + /// Returns PP_ERROR_NOMEMORY if frame and bitstream buffers can't be created. + int32_t Initialize(const PP_VideoFrame_Format& input_format, + const Size& input_visible_size, + const PP_VideoProfile& output_profile, + const uint32_t initial_bitrate, + PP_HardwareAcceleration acceleration, + const CompletionCallback& cc); + + /// Gets the number of input video frames that the encoder may hold while + /// encoding. If the plugin is providing the video frames, it should have at + /// least this many available. + /// + /// @return An int32_t containing the number of frames required, or an error + /// code from <code>pp_errors.h</code>. + /// Returns PP_ERROR_FAILED if Initialize() has not successfully completed. + int32_t GetFramesRequired(); + + /// Gets the coded size of the video frames required by the encoder. Coded + /// size is the logical size of the input frames, in pixels. The encoder may + /// have hardware alignment requirements that make this different from + /// |input_visible_size|, as requested in the call to Initialize(). + /// + /// @param[in] coded_size A <code>Size</code> to hold the coded size. + /// + /// @return An int32_t containing a result code from <code>pp_errors.h</code>. + /// Returns PP_ERROR_FAILED if Initialize() has not successfully completed. + int32_t GetFrameCodedSize(Size* coded_size); + + /// Gets a blank video frame which can be filled with video data and passed + /// to the encoder. + /// + /// @param[in] callback A <code>CompletionCallbackWithOutput</code> to be + /// called upon completion with the blank <code>VideoFrame</code> resource. + /// + /// @return An int32_t containing an error code from <code>pp_errors.h</code>. + int32_t GetVideoFrame(const CompletionCallbackWithOutput<VideoFrame>& cc); + + /// Encodes a video frame. + /// + /// @param[in] video_frame The <code>VideoFrame</code> to be encoded. + /// @param[in] force_keyframe A <code>PP_Bool> specifying whether the encoder + /// should emit a key frame for this video frame. + /// @param[in] callback A <code>CompletionCallback</code> to be called upon + /// completion. Plugins that pass <code>VideoFrame</code> resources owned + /// by other resources should wait for completion before reusing them. + /// + /// @return An int32_t containing an error code from <code>pp_errors.h</code>. + /// Returns PP_ERROR_FAILED if Initialize() has not successfully completed. + int32_t Encode(const VideoFrame& video_frame, + bool force_keyframe, + const CompletionCallback& cc); + + /// Gets the next encoded bitstream buffer from the encoder. + /// + /// @param[out] bitstream_buffer A <code>PP_BitstreamBuffer</code> containing + /// encoded video data. + /// @param[in] callback A <code>CompletionCallbackWithOutput</code> to be + /// called upon completion with the next bitstream buffer. The plugin can call + /// GetBitstreamBuffer from the callback in order to continuously "pull" + /// bitstream buffers from the encoder. + /// + /// @return An int32_t containing an error code from <code>pp_errors.h</code>. + /// Returns PP_ERROR_FAILED if Initialize() has not successfully completed. + /// Returns PP_ERROR_INPROGRESS if a prior call to GetBitstreamBuffer() has + /// not completed. + int32_t GetBitstreamBuffer( + const CompletionCallbackWithOutput<PP_BitstreamBuffer>& cc); + + /// Recycles a bitstream buffer back to the encoder. + /// + /// @param[in] bitstream_buffer A <code>PP_BitstreamBuffer</code> that is no + /// longer needed by the plugin. + void RecycleBitstreamBuffer(const PP_BitstreamBuffer& bitstream_buffer); + + /// Requests a change to encoding parameters. This is only a request, + /// fulfilled on a best-effort basis. + /// + /// @param[in] bitrate The requested new bitrate, in bits per second. + /// @param[in] framerate The requested new framerate, in frames per second. + void RequestEncodingParametersChange(uint32_t bitrate, uint32_t framerate); + + /// Closes the video encoder, and cancels any pending encodes. Any pending + /// callbacks will still run, reporting <code>PP_ERROR_ABORTED</code> . It is + /// not valid to call any encoder functions after a call to this method. + /// <strong>Note:</strong> Destroying the video encoder closes it implicitly, + /// so you are not required to call Close(). + void Close(); +}; + +} // namespace pp + +#endif // PPAPI_CPP_VIDEO_ENCODER_H_ |