/*************************************************************************
* Copyright (C) [2019] by Cambricon, Inc. All rights reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*************************************************************************/
/**
* @file easy_encode.h
*
* This file contains a declaration of the EasyDecode class and involved structures.
*/
#ifndef EASYCODEC_EASY_ENCODE_H_
#define EASYCODEC_EASY_ENCODE_H_
#include <functional>
#include <memory>
#include "cxxutil/edk_attribute.h"
#include "cxxutil/exception.h"
#include "easycodec/vformat.h"
namespace edk {
/**
* @brief Rate control parameters
*/
struct RateControl {
/// Using variable bit rate or constant bit rate
bool vbr{false};
/// The interval of ISLICE.
uint32_t gop{0};
/// The numerator of encode frame rate of the venc channel
uint32_t frame_rate_num{0};
/// The denominator of encode frame rate of the venc channel
uint32_t frame_rate_den{0};
/// Average bitrate in unit of kpbs, for cbr only.
uint32_t bit_rate{0};
/// The max bitrate in unit of kbps, for vbr only .
uint32_t max_bit_rate{0};
/// The max qp, range [min_qp, 51]
uint32_t max_qp{0};
/// The min qp, range [0, max_qp]
uint32_t min_qp{0};
};
/**
* @brief Video profile enumaration.
*/
enum class VideoProfile {
H264_BASELINE = 0,
H264_MAIN,
H264_HIGH,
H264_HIGH_10,
H265_MAIN,
H265_MAIN_STILL,
H265_MAIN_INTRA,
H265_MAIN_10,
PROFILE_MAX
};
/**
* @brief Video codec level
*/
enum class VideoLevel {
H264_1 = 0,
H264_1B,
H264_11,
H264_12,
H264_13,
H264_2,
H264_21,
H264_22,
H264_3,
H264_31,
H264_32,
H264_4,
H264_41,
H264_42,
H264_5,
H264_51,
H265_MAIN_1,
H265_HIGH_1,
H265_MAIN_2,
H265_HIGH_2,
H265_MAIN_21,
H265_HIGH_21,
H265_MAIN_3,
H265_HIGH_3,
H265_MAIN_31,
H265_HIGH_31,
H265_MAIN_4,
H265_HIGH_4,
H265_MAIN_41,
H265_HIGH_41,
H265_MAIN_5,
H265_HIGH_5,
H265_MAIN_51,
H265_HIGH_51,
H265_MAIN_52,
H265_HIGH_52,
H265_MAIN_6,
H265_HIGH_6,
H265_MAIN_61,
H265_HIGH_61,
H265_MAIN_62,
H265_HIGH_62,
LEVEL_MAX
};
/*
* @brief cncodec GOP type, see developer guide
*/
enum class GopType { BIDIRECTIONAL, LOW_DELAY, PYRAMID };
/**
* @brief Encode packet callback function type
* @param CnPacket Packet containing encoded frame information
*/
using EncodePacketCallback = std::function<void(const CnPacket&)>;
/// Encode EOS callback function type
using EncodeEosCallback = std::function<void()>;
class EncodeHandler;
/**
* @brief Easy encoder class, provide a fast and easy API to encode on MLU platform.
*/
class EasyEncode {
public:
friend class EncodeHandler;
/**
* @brief params for creating EasyEncode
*/
struct Attr {
/// The maximum resolution that this endecoder can handle.
Geometry frame_geometry;
/**
* @brief Input pixel format
* @note h264/h265 support NV21/NV12/I420/RGBA/BGRA/ARGB/ABGR
* jpeg support NV21/NV12
*/
PixelFmt pixel_format;
/**
* @brief output codec type
* @note support h264/h265/jpeg
*/
CodecType codec_type = CodecType::H264;
/// Color space standard
ColorStd color_std = ColorStd::ITU_BT_709;
/// Qulity factor for jpeg encoder.
uint32_t jpeg_qfactor = 50;
/// Profile for video encoder.
VideoProfile profile = VideoProfile::H264_MAIN;
/// Video encode level
VideoLevel level = VideoLevel::H264_41;
/// Video rate control parameters.
RateControl rate_control;
/// Input buffer number
uint32_t input_buffer_num = 3;
/// Output buffer number
uint32_t output_buffer_num = 4;
/// P frame number in gop default 0
uint32_t p_frame_num = 0;
/// B frame number in gop when profile is above main, default 0
uint32_t b_frame_num = 0;
/// GOP type, @see edk::GopType
GopType gop_type = GopType::BIDIRECTIONAL;
/// insert SPS/PPS before IDR,1, insert, 0 not
bool insert_spspps_when_idr = true;
/// Whether to print encoder attribute
bool silent = false;
/// Callback for receive packet
EncodePacketCallback packet_callback = NULL;
/// Callback for receive eos
EncodeEosCallback eos_callback = NULL;
/// Indentification to specify device on which create encoder
int dev_id = 0;
};
/**
* @brief Create encoder by attr. Throw a Exception while error encountered.
* @param attr Encoder attribute description
* @return Pointer to new encoder instance
*/
static std::unique_ptr<EasyEncode> New(const Attr& attr);
/**
* @brief Abort encoder instance at once
* @note aborted encoder instance cannot be used any more
*/
void AbortEncoder();
/**
* @brief Get the encoder instance attribute
* @return Encoder attribute
*/
Attr GetAttr() const;
/**
* @brief Destroy the Easy Encode object
*/
~EasyEncode();
/**
* @brief send frame to encoder.
* @param frame CNframe
* @param eos default false
* @return Return false if send data failed.
*/
bool SendDataCPU(const CnFrame& frame, bool eos = false);
/**
* @brief Release encoder buffer.
* @note Release encoder buffer each time received packet while packet content will not be used,
* otherwise encoder may be blocked.
* @param buf_id Codec buffer id.
*/
void ReleaseBuffer(uint64_t buf_id);
private:
EasyEncode();
EncodeHandler* handler_ = nullptr;
EasyEncode(const EasyEncode&) = delete;
const EasyEncode& operator=(const EasyEncode&) = delete;
}; // class EasyEncode
} // namespace edk
#endif // EASYCODEC_EASY_ENCODE_H_