diff options
Diffstat (limited to 'tinyDAV/src/codecs/h264/tdav_codec_h264_cisco.cxx')
| -rw-r--r-- | tinyDAV/src/codecs/h264/tdav_codec_h264_cisco.cxx | 882 |
1 files changed, 882 insertions, 0 deletions
diff --git a/tinyDAV/src/codecs/h264/tdav_codec_h264_cisco.cxx b/tinyDAV/src/codecs/h264/tdav_codec_h264_cisco.cxx new file mode 100644 index 0000000..a501221 --- /dev/null +++ b/tinyDAV/src/codecs/h264/tdav_codec_h264_cisco.cxx @@ -0,0 +1,882 @@ +/* +* Copyright (C) 2014-2015 Mamadou DIOP. +* +* +* This file is part of Open Source Doubango Framework. +* +* DOUBANGO is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* DOUBANGO is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with DOUBANGO. +* +*/ + +/**@file tdav_codec_h264_cisco.cxx + * @brief H.264 codec plugin using OpenH264 (https://github.com/cisco/openh264) v1.1 for encoding/decoding. + */ +#include "tinydav/codecs/h264/tdav_codec_h264_cisco.h" + +#if HAVE_OPENH264 + +#include "tinydav/codecs/h264/tdav_codec_h264_common.h" + +#include "tinyrtp/rtp/trtp_rtp_packet.h" + +#include "tinymedia/tmedia_codec.h" +#include "tinymedia/tmedia_params.h" +#include "tinymedia/tmedia_defaults.h" + +#include "tsk_mutex.h" +#include "tsk_params.h" +#include "tsk_memory.h" +#include "tsk_debug.h" + +extern "C" { +#include <wels/codec_api.h> +#include <wels/codec_app_def.h> +} + +#include <limits.h> /* INT_MAX */ + +typedef struct tdav_codec_h264_cisco_s +{ + TDAV_DECLARE_CODEC_H264_COMMON; + + // Encoder + struct{ + ISVCEncoder *pInst; + SEncParamExt sEncParam; + SSourcePicture sEncPic; + void* buffer; + int64_t frame_count; + tsk_bool_t force_idr; + int rotation; + int neg_width; + int neg_height; + int neg_fps; + tsk_mutex_handle_t* mutex; + } encoder; + + // decoder + struct{ + ISVCDecoder* pInst; + void* accumulator; + tsk_size_t accumulator_pos; + tsk_size_t accumulator_size; + uint16_t last_seq; + } decoder; +} +tdav_codec_h264_cisco_t; + +#if !defined(CISCO_H264_GOP_SIZE_IN_SECONDS) +# define CISCO_H264_GOP_SIZE_IN_SECONDS 25 +#endif + +#define kResetRotationTrue tsk_true +#define kResetRotationFalse tsk_false + +static int tdav_codec_h264_cisco_init(tdav_codec_h264_cisco_t* self, profile_idc_t profile); +static int tdav_codec_h264_cisco_deinit(tdav_codec_h264_cisco_t* self); +static int tdav_codec_h264_cisco_open_encoder(tdav_codec_h264_cisco_t* self); +static int tdav_codec_h264_cisco_close_encoder(tdav_codec_h264_cisco_t* self, tsk_bool_t reset_rotation); +static int tdav_codec_h264_cisco_open_decoder(tdav_codec_h264_cisco_t* self); +static int tdav_codec_h264_cisco_close_decoder(tdav_codec_h264_cisco_t* self); +static ELevelIdc tdav_codec_h264_cisco_convert_level(enum level_idc_e level); +static void tdav_codec_h264_cisco_debug_cb(void* context, int level, const char* message); + +static void (*__tdav_codec_h264_cisco_debug_cb)(void* context, int level, const char* message) = tdav_codec_h264_cisco_debug_cb; + +/* ============ H.264 Base/Main Profile X.X Plugin interface functions ================= */ + +static int tdav_codec_h264_cisco_set(tmedia_codec_t* self, const tmedia_param_t* param) +{ + tdav_codec_h264_cisco_t* h264 = (tdav_codec_h264_cisco_t*)self; + tsk_bool_t reconf = tsk_false; + if (param->value_type == tmedia_pvt_int32) { + if (tsk_striequals(param->key, "action")) { + tmedia_codec_action_t action = (tmedia_codec_action_t)TSK_TO_INT32((uint8_t*)param->value); + switch (action) { + case tmedia_codec_action_encode_idr: + { + TSK_DEBUG_INFO("OpenH264 force_idr action"); + h264->encoder.force_idr = tsk_true; + return 0; + } + case tmedia_codec_action_bw_up: + case tmedia_codec_action_bw_down: + { + int32_t rc_target_bitrate; + int32_t bandwidth_max_upload_bps = TMEDIA_CODEC(h264)->bandwidth_max_upload == INT_MAX ? TMEDIA_CODEC(h264)->bandwidth_max_upload : (TMEDIA_CODEC(h264)->bandwidth_max_upload * 1024); // kbps -> bps + if (action == tmedia_codec_action_bw_up) { + rc_target_bitrate = TSK_CLAMP(0, (int32_t)((h264->encoder.sEncParam.iTargetBitrate * 3) >> 1), bandwidth_max_upload_bps); + } + else { + rc_target_bitrate = TSK_CLAMP(0, (int32_t)((h264->encoder.sEncParam.iTargetBitrate << 1) / 3), bandwidth_max_upload_bps); + } + h264->encoder.sEncParam.iTargetBitrate = rc_target_bitrate; + h264->encoder.sEncParam.iMaxBitrate = rc_target_bitrate; + SSpatialLayerConfig* layer = &h264->encoder.sEncParam.sSpatialLayers[0]; + layer->iMaxSpatialBitrate = h264->encoder.sEncParam.iMaxBitrate; + layer->iSpatialBitrate = h264->encoder.sEncParam.iTargetBitrate; + reconf = tsk_true; + TSK_DEBUG_INFO("OpenH264 new target bitrate = %d bps", rc_target_bitrate); + break; + } + } + } + else if (tsk_striequals(param->key, "bw_kbps")) { // both up and down (from the SDP) + int32_t max_bw_userdefine_kbps = tmedia_defaults_get_bandwidth_video_upload_max(); + int32_t max_bw_new_kbps = *((int32_t*)param->value); + if (max_bw_userdefine_kbps > 0) { + // do not use more than what the user defined in it's configuration + TMEDIA_CODEC(h264)->bandwidth_max_upload = TSK_MIN(max_bw_new_kbps, max_bw_userdefine_kbps); + } + else { + TMEDIA_CODEC(h264)->bandwidth_max_upload = max_bw_new_kbps; + } + TSK_DEBUG_INFO("OpenH264 codec: bandwidth-max-upload= %d kbps", TMEDIA_CODEC(h264)->bandwidth_max_upload); + reconf = tsk_true; + } + else if (tsk_striequals(param->key, "bandwidth-max-upload")) { + int32_t bw_max_upload_kbps = *((int32_t*)param->value); + TSK_DEBUG_INFO("OpenH264 codec: bandwidth-max-upload= %d kbps", bw_max_upload_kbps); + TMEDIA_CODEC(h264)->bandwidth_max_upload = bw_max_upload_kbps; + reconf = tsk_true; + } + else if (tsk_striequals(param->key, "rotation")) { + int rotation = *((int32_t*)param->value); + if (h264->encoder.rotation != rotation) { + h264->encoder.rotation = rotation; + if (self->opened) { + int ret; + if ((ret = tdav_codec_h264_cisco_close_encoder(h264, kResetRotationFalse))) { + return ret; + } + if ((ret = tdav_codec_h264_cisco_open_encoder(h264))) { + return ret; + } + } + } + return 0; + } + } + + if (reconf) { + if (h264->encoder.pInst) { + long err; + // lock required because of https://code.google.com/p/doubango/issues/detail?id=422 + tsk_mutex_lock(h264->encoder.mutex); + err = h264->encoder.pInst->InitializeExt(&h264->encoder.sEncParam); + tsk_mutex_unlock(h264->encoder.mutex); + if (err != cmResultSuccess) { + TSK_DEBUG_ERROR("InitializeExt failed: %ld", err); + return -1; + } + } + return 0; + } + + return -1; +} + + +static int tdav_codec_h264_cisco_open(tmedia_codec_t* self) +{ + int ret; + tdav_codec_h264_cisco_t* h264 = (tdav_codec_h264_cisco_t*)self; + + if (!h264) { + TSK_DEBUG_ERROR("Invalid parameter"); + return -1; + } + + /* the caller (base class) already checked that the codec is not opened */ + + // Encoder + if ((ret = tdav_codec_h264_cisco_open_encoder(h264))) { + return ret; + } + + // Decoder + if ((ret = tdav_codec_h264_cisco_open_decoder(h264))) { + return ret; + } + + return 0; +} + +static int tdav_codec_h264_cisco_close(tmedia_codec_t* self) +{ + tdav_codec_h264_cisco_t* h264 = (tdav_codec_h264_cisco_t*)self; + + if (!h264) { + TSK_DEBUG_ERROR("Invalid parameter"); + return -1; + } + + /* the caller (base class) already checked that the codec is opened */ + + // Encoder + tdav_codec_h264_cisco_close_encoder(h264, kResetRotationTrue); + + // Decoder + tdav_codec_h264_cisco_close_decoder(h264); + + return 0; +} + +static tsk_size_t tdav_codec_h264_cisco_encode(tmedia_codec_t* self, const void* in_data, tsk_size_t in_size, void** out_data, tsk_size_t* out_max_size) +{ + long err; + tsk_bool_t send_idr, send_hdr; + tsk_size_t in_xsize; + SFrameBSInfo bsInfo; + + tdav_codec_h264_cisco_t* h264 = (tdav_codec_h264_cisco_t*)self; + tdav_codec_h264_common_t* common = (tdav_codec_h264_common_t*)self; + + if (!self || !in_data || !in_size) { + TSK_DEBUG_ERROR("Invalid parameter"); + return 0; + } + + if (!self->opened || !h264->encoder.pInst) { + TSK_DEBUG_ERROR("Encoder not opened or not ready"); + return 0; + } + + in_xsize = (h264->encoder.sEncPic.iPicHeight * h264->encoder.sEncPic.iPicWidth * 3) >> 1; + if (in_xsize != in_size){ + /* guard */ + TSK_DEBUG_ERROR("Invalid size: %u<>%u", in_xsize, in_size); + return 0; + } + + // send IDR for: + // - the first frame + // - remote peer requested an IDR + // - every second within the first 4seconds + send_idr = ( + h264->encoder.frame_count++ == 0 + || h264 ->encoder.force_idr + //|| ( (h264->encoder.frame_count < (int)TMEDIA_CODEC_VIDEO(h264)->out.fps * 4) && ((h264->encoder.frame_count % TMEDIA_CODEC_VIDEO(h264)->out.fps)==0) ) + ); + + // send SPS and PPS headers for: + // - IDR frames (not required but it's the easiest way to deal with pkt loss) + // - every 5 seconds after the first 4seconds + send_hdr = ( + send_idr + //|| ( (h264->encoder.frame_count % (TMEDIA_CODEC_VIDEO(h264)->out.fps * 5))==0 ) + ); + + if (send_idr) { + TSK_DEBUG_INFO("OpenH264 call ForceIntraFrame"); + if ((err = h264->encoder.pInst->ForceIntraFrame(true)) != cmResultSuccess) { + TSK_DEBUG_WARN("OpenH264 ForceIntraFrame(%d) failed: %ld", send_idr, err); + } + } + if (send_hdr) { +#if 0 // Not needed + memset(&bsInfo, 0, sizeof(bsInfo)); + tsk_mutex_lock(h264->encoder.mutex); + if ((err = h264->encoder.pInst->EncodeParameterSets(&bsInfo)) != cmResultSuccess) { + TSK_DEBUG_WARN("OpenH264 EncodeParameterSets(%d) failed: %ld", send_idr, err); + } + else { + for (int iLayerNum = 0; iLayerNum < bsInfo.iLayerNum; ++iLayerNum) { + unsigned char* pBsBuf = bsInfo.sLayerInfo[iLayerNum].pBsBuf; + int iNalLengthInByte = 0, _iNalLengthInByte; + for (int iNalCount = 0; iNalCount < bsInfo.sLayerInfo[iLayerNum].iNalCount; ++iNalCount) { + if ((_iNalLengthInByte = bsInfo.sLayerInfo[iLayerNum].pNalLengthInByte[iNalCount]) > 0) { + iNalLengthInByte += _iNalLengthInByte; + } + } + if (iNalLengthInByte > 0) { + tdav_codec_h264_rtp_encap(TDAV_CODEC_H264_COMMON(h264), pBsBuf, (tsk_size_t)iNalLengthInByte); + } + } + } + tsk_mutex_unlock(h264->encoder.mutex); +#endif + } + + h264->encoder.sEncPic.pData[0] = ((unsigned char*)in_data); + h264->encoder.sEncPic.pData[1] = h264->encoder.sEncPic.pData[0] + (h264->encoder.sEncPic.iPicHeight * h264->encoder.sEncPic.iPicWidth); + h264->encoder.sEncPic.pData[2] = h264->encoder.sEncPic.pData[1] + ((h264->encoder.sEncPic.iPicHeight * h264->encoder.sEncPic.iPicWidth) >> 2); + // h264->encoder.sEncPic.uiTimeStamp = rand(); + + memset(&bsInfo, 0, sizeof(bsInfo)); + + tsk_mutex_lock(h264->encoder.mutex); + if ((err = h264->encoder.pInst->EncodeFrame(&h264->encoder.sEncPic, &bsInfo)) != cmResultSuccess) { + TSK_DEBUG_ERROR("OpenH264 setting EncodeFrame() failed: %ld", err); + tsk_mutex_unlock(h264->encoder.mutex); + return 0; + } + + // Memory held by bsInfo is freed when "InitializeExt()" is called this is why the unlock is after reading the output stream + if (bsInfo.eFrameType != videoFrameTypeInvalid) { + for (int iLayerNum = 0; iLayerNum < bsInfo.iLayerNum; ++iLayerNum) { + unsigned char* pBsBuf = bsInfo.sLayerInfo[iLayerNum].pBsBuf; + int iNalLengthInByte = 0, _iNalLengthInByte; + for (int iNalCount = 0; iNalCount < bsInfo.sLayerInfo[iLayerNum].iNalCount; ++iNalCount) { + if ((_iNalLengthInByte = bsInfo.sLayerInfo[iLayerNum].pNalLengthInByte[iNalCount]) > 0) { + iNalLengthInByte += _iNalLengthInByte; + } + } + if (iNalLengthInByte > 0) { + tdav_codec_h264_rtp_encap(TDAV_CODEC_H264_COMMON(h264), pBsBuf, (tsk_size_t)iNalLengthInByte); + } + } + } + tsk_mutex_unlock(h264->encoder.mutex); + + h264 ->encoder.force_idr = tsk_false; // reset + + return 0; +} + +static tsk_size_t tdav_codec_h264_cisco_decode(tmedia_codec_t* self, const void* in_data, tsk_size_t in_size, void** out_data, tsk_size_t* out_max_size, const tsk_object_t* proto_hdr) +{ + tdav_codec_h264_cisco_t* h264 = (tdav_codec_h264_cisco_t*)self; + const trtp_rtp_header_t* rtp_hdr = (const trtp_rtp_header_t*)proto_hdr; + + const uint8_t* pay_ptr = tsk_null; + tsk_size_t pay_size = 0; + int ret; + long err = cmResultSuccess; + tsk_bool_t append_scp, end_of_unit, got_picture_ptr = tsk_false; + tsk_bool_t sps_or_pps; + tsk_size_t retsize = 0, size_to_copy = 0; + static const tsk_size_t xmax_size = (3840 * 2160 * 3) >> 3; // >>3 instead of >>1 (not an error) + static tsk_size_t start_code_prefix_size = sizeof(H264_START_CODE_PREFIX); + + if (!h264 || !in_data || !in_size || !out_data) { + TSK_DEBUG_ERROR("Invalid parameter"); + return 0; + } + + if (!self->opened || !h264->encoder.pInst) { + TSK_DEBUG_ERROR("Decoder not opened or not ready"); + return 0; + } + + /* Packet lost? */ + if ((h264->decoder.last_seq + 1) != rtp_hdr->seq_num && h264->decoder.last_seq) { + TSK_DEBUG_INFO("[H.264] Packet loss, seq_num=%d", (h264->decoder.last_seq + 1)); + } + h264->decoder.last_seq = rtp_hdr->seq_num; + + + /* 5.3. NAL Unit Octet Usage + +---------------+ + |0|1|2|3|4|5|6|7| + +-+-+-+-+-+-+-+-+ + |F|NRI| Type | + +---------------+ + */ + if (*((uint8_t*)in_data) & 0x80) { + TSK_DEBUG_WARN("F=1"); + /* reset accumulator */ + h264->decoder.accumulator_pos = 0; + return 0; + } + + /* get payload */ + if ((ret = tdav_codec_h264_get_pay(in_data, in_size, (const void**)&pay_ptr, &pay_size, &append_scp, &end_of_unit)) || !pay_ptr || !pay_size) { + TSK_DEBUG_ERROR("Depayloader failed to get H.264 content"); + return 0; + } + //append_scp = tsk_true; + size_to_copy = pay_size + (append_scp ? start_code_prefix_size : 0); + // whether it's SPS or PPS (append_scp is false for subsequent FUA chuncks) + sps_or_pps = append_scp && pay_ptr && ((pay_ptr[0] & 0x1F) == 7 || (pay_ptr[0] & 0x1F) == 8); + + // start-accumulator + if (!h264->decoder.accumulator) { + if (size_to_copy > xmax_size) { + TSK_DEBUG_ERROR("%u too big to contain valid encoded data. xmax_size=%u", size_to_copy, xmax_size); + return 0; + } + if (!(h264->decoder.accumulator = tsk_calloc(size_to_copy, sizeof(uint8_t)))) { + TSK_DEBUG_ERROR("Failed to allocated new buffer"); + return 0; + } + h264->decoder.accumulator_size = size_to_copy; + } + if ((h264->decoder.accumulator_pos + size_to_copy) >= xmax_size) { + TSK_DEBUG_ERROR("BufferOverflow"); + h264->decoder.accumulator_pos = 0; + return 0; + } + if ((h264->decoder.accumulator_pos + size_to_copy) > h264->decoder.accumulator_size) { + if (!(h264->decoder.accumulator = tsk_realloc(h264->decoder.accumulator, (h264->decoder.accumulator_pos + size_to_copy)))) { + TSK_DEBUG_ERROR("Failed to reallocated new buffer"); + h264->decoder.accumulator_pos = 0; + h264->decoder.accumulator_size = 0; + return 0; + } + h264->decoder.accumulator_size = (h264->decoder.accumulator_pos + size_to_copy); + } + + if (append_scp) { + memcpy(&((uint8_t*)h264->decoder.accumulator)[h264->decoder.accumulator_pos], H264_START_CODE_PREFIX, start_code_prefix_size); + h264->decoder.accumulator_pos += start_code_prefix_size; + } + memcpy(&((uint8_t*)h264->decoder.accumulator)[h264->decoder.accumulator_pos], pay_ptr, pay_size); + h264->decoder.accumulator_pos += pay_size; + // end-accumulator + + if (/*rtp_hdr->marker*/end_of_unit) { + /* decode the picture */ + unsigned char* out_ptr[3] = { NULL }; + int out_stride[2] = {0}, out_width = 0, out_height = 0; + tsk_size_t out_xsize; + + // Decode a Unit + err = h264->decoder.pInst->DecodeFrame( + (const unsigned char*)h264->decoder.accumulator, h264->decoder.accumulator_pos, + out_ptr, out_stride, out_width, out_height); + + if (err != cmResultSuccess) { + if (0 && err == dsDataErrorConcealed) { + TSK_DEBUG_INFO("OpenH264: Data error concealed"); + err = cmResultSuccess; + } + else { + TSK_DEBUG_WARN("OpenH264: DecodeFrame failed: %ld", err); + goto bail; + } + } + // Do we have a complete frame? + if (!(got_picture_ptr = ((out_ptr[0] && out_ptr[1] && out_ptr[2]) && (out_stride[0] && out_stride[1]) && out_width && out_height))) { + goto bail; + } + out_xsize = (out_width * out_height * 3) >> 1; // I420 + /* IDR ? */ + if (((pay_ptr[0] & 0x1F) == 0x05) && TMEDIA_CODEC_VIDEO(self)->in.callback) { + TSK_DEBUG_INFO("Decoded H.264 IDR"); + TMEDIA_CODEC_VIDEO(self)->in.result.type = tmedia_video_decode_result_type_idr; + TMEDIA_CODEC_VIDEO(self)->in.result.proto_hdr = proto_hdr; + TMEDIA_CODEC_VIDEO(self)->in.callback(&TMEDIA_CODEC_VIDEO(self)->in.result); + } + /* fill out */ + if (*out_max_size < out_xsize) { + if ((*out_data = tsk_realloc(*out_data, out_xsize))){ + *out_max_size = out_xsize; + } + else { + *out_max_size = 0; + return 0; + } + } + TMEDIA_CODEC_VIDEO(h264)->in.width = out_width; + TMEDIA_CODEC_VIDEO(h264)->in.height = out_height; + /* layout picture */ + { + int plane, y, stride; + retsize = 0; + for (plane=0; plane < 3; plane++) { + unsigned char *buf = out_ptr[plane]; + stride = out_stride[plane ? 1 : 0]; + for (y=0; y<out_height >> (plane ? 1 : 0); y++) { + unsigned int w_count = out_width >> (plane ? 1 : 0); + if ((ret + w_count) > *out_max_size) { + TSK_DEBUG_ERROR("BufferOverflow"); + ret = 0; + goto bail; + } + memcpy(((uint8_t*)*out_data) + retsize, buf, w_count); + retsize += w_count; + buf += stride; + } + } + } + } // else if(rtp_hdr->marker) + +bail: + /* end of frame */ + if (got_picture_ptr) { + int32_t endOfStream = 1; + err = h264->decoder.pInst->SetOption(DECODER_OPTION_END_OF_STREAM, (void*)&endOfStream); + if (err != cmResultSuccess) { + TSK_DEBUG_WARN("OpenH264 setting DECODER_OPTION_END_OF_STREAM failed: %ld", err); + goto bail; + } + } + if (/*rtp_hdr->marker*/end_of_unit) { + /* reset accumulator */ + h264->decoder.accumulator_pos = 0; + } + if (err != cmResultSuccess){ + TSK_DEBUG_INFO("Failed to decode the buffer with error code =%ld, size=%u, append=%s", err, h264->decoder.accumulator_pos, append_scp ? "yes" : "no"); + if (TMEDIA_CODEC_VIDEO(self)->in.callback) { + TMEDIA_CODEC_VIDEO(self)->in.result.type = tmedia_video_decode_result_type_error; + TMEDIA_CODEC_VIDEO(self)->in.result.proto_hdr = proto_hdr; + TMEDIA_CODEC_VIDEO(self)->in.callback(&TMEDIA_CODEC_VIDEO(self)->in.result); + } + } + return retsize; +} + +static tsk_bool_t tdav_codec_h264_cisco_sdp_att_match(const tmedia_codec_t* self, const char* att_name, const char* att_value) +{ + return tdav_codec_h264_common_sdp_att_match((tdav_codec_h264_common_t*)self, att_name, att_value); +} + +static char* tdav_codec_h264_cisco_sdp_att_get(const tmedia_codec_t* self, const char* att_name) +{ + char* att = tdav_codec_h264_common_sdp_att_get((const tdav_codec_h264_common_t*)self, att_name); + if (att && tsk_striequals(att_name, "fmtp")) { + tsk_strcat(&att, "; impl=openh264"); + } + return att; +} + +/* ============ H.264 Base Profile Plugin interface ================= */ + +/* constructor */ +static tsk_object_t* tdav_codec_h264_cisco_base_ctor(tsk_object_t * self, va_list * app) +{ + tdav_codec_h264_cisco_t *h264 = (tdav_codec_h264_cisco_t*)self; + if (h264) { + /* init base: called by tmedia_codec_create() */ + /* init self */ + if (tdav_codec_h264_cisco_init(h264, profile_idc_baseline) != 0) { + return tsk_null; + } + } + return self; +} +/* destructor */ +static tsk_object_t* tdav_codec_h264_cisco_base_dtor(tsk_object_t * self) +{ + tdav_codec_h264_cisco_t *h264 = (tdav_codec_h264_cisco_t*)self; + if (h264) { + /* deinit base */ + tdav_codec_h264_common_deinit(TDAV_CODEC_H264_COMMON(self)); + /* deinit self */ + tdav_codec_h264_cisco_deinit(h264); + } + + return self; +} +/* object definition */ +static const tsk_object_def_t tdav_codec_h264_cisco_base_def_s = +{ + sizeof(tdav_codec_h264_cisco_t), + tdav_codec_h264_cisco_base_ctor, + tdav_codec_h264_cisco_base_dtor, + tmedia_codec_cmp, +}; +/* plugin definition*/ +static const tmedia_codec_plugin_def_t tdav_codec_h264_cisco_base_plugin_def_s = +{ + &tdav_codec_h264_cisco_base_def_s, + + tmedia_video, + tmedia_codec_id_h264_bp, + "H264", + "H264 Base Profile (OpenH264)", + TMEDIA_CODEC_FORMAT_H264_BP, + tsk_true, + 90000, // rate + + /* audio */ + { 0 }, + + /* video (width, height, fps) */ + {176, 144, 0}, // fps is @deprecated + + tdav_codec_h264_cisco_set, + tdav_codec_h264_cisco_open, + tdav_codec_h264_cisco_close, + tdav_codec_h264_cisco_encode, + tdav_codec_h264_cisco_decode, + tdav_codec_h264_cisco_sdp_att_match, + tdav_codec_h264_cisco_sdp_att_get +}; +const tmedia_codec_plugin_def_t *tdav_codec_h264_cisco_base_plugin_def_t = &tdav_codec_h264_cisco_base_plugin_def_s; + +/* ============ Common To all H264 profiles ================= */ + +static int tdav_codec_h264_cisco_open_encoder(tdav_codec_h264_cisco_t* self) +{ + int ret = -1, max_bitrate_bps; + long err; + SSpatialLayerConfig* layer; + + int32_t max_bw_kpbs; + tdav_codec_h264_common_t* common = (tdav_codec_h264_common_t*)self; + + if (self->encoder.pInst) { + TSK_DEBUG_ERROR("Encoder already initialized"); + goto bail; + } + + // create encoder + if ((err = WelsCreateSVCEncoder(&self->encoder.pInst)) != cmResultSuccess) { + TSK_DEBUG_ERROR("Failed to create ancoder: %ld", err); + goto bail; + } + + self->encoder.pInst->SetOption(ENCODER_OPTION_TRACE_CALLBACK_CONTEXT, self); + self->encoder.pInst->SetOption(ENCODER_OPTION_TRACE_CALLBACK, &__tdav_codec_h264_cisco_debug_cb); + + if ((err = self->encoder.pInst->GetDefaultParams(&self->encoder.sEncParam)) != cmResultSuccess) { + TSK_DEBUG_ERROR("GetDefaultParams failed: %ld", err); + goto bail; + } + + self->encoder.neg_width = (self->encoder.rotation == 90 || self->encoder.rotation == 270) ? TMEDIA_CODEC_VIDEO(self)->out.height : TMEDIA_CODEC_VIDEO(self)->out.width; + self->encoder.neg_height = (self->encoder.rotation == 90 || self->encoder.rotation == 270) ? TMEDIA_CODEC_VIDEO(self)->out.width : TMEDIA_CODEC_VIDEO(self)->out.height; + self->encoder.neg_fps = TMEDIA_CODEC_VIDEO(self)->out.fps; + max_bw_kpbs = TSK_CLAMP( + 0, + tmedia_get_video_bandwidth_kbps_2(self->encoder.neg_width, self->encoder.neg_height, self->encoder.neg_fps), + TMEDIA_CODEC(self)->bandwidth_max_upload + ); + max_bitrate_bps = (max_bw_kpbs * 1024); + + TSK_DEBUG_INFO("[H.264 OpenH264 Encoder] neg_width=%d, neg_height=%d, neg_fps=%d, max_bitrate_bps=%d", + self->encoder.neg_width, + self->encoder.neg_height, + self->encoder.neg_fps, + max_bitrate_bps + ); + + self->encoder.sEncParam.iInputCsp = videoFormatI420; + self->encoder.sEncParam.iSpatialLayerNum = 1; + self->encoder.sEncParam.iTemporalLayerNum = 1; + self->encoder.sEncParam.uiIntraPeriod = (self->encoder.neg_fps * CISCO_H264_GOP_SIZE_IN_SECONDS); + self->encoder.sEncParam.iUsageType = CAMERA_VIDEO_REAL_TIME; // TODO: use "SCREEN_CONTENT_REAL_TIME" screencast + self->encoder.sEncParam.iPicWidth = self->encoder.neg_width; + self->encoder.sEncParam.iPicHeight = self->encoder.neg_height; + self->encoder.sEncParam.iTargetBitrate = max_bitrate_bps; + self->encoder.sEncParam.iMaxBitrate = max_bitrate_bps; + self->encoder.sEncParam.fMaxFrameRate = (float)self->encoder.neg_fps; + self->encoder.sEncParam.uiMaxNalSize = H264_RTP_PAYLOAD_SIZE; + self->encoder.sEncParam.bEnableSpsPpsIdAddition = true; + self->encoder.sEncParam.bEnableFrameCroppingFlag = true; + + layer = &self->encoder.sEncParam.sSpatialLayers[0]; + layer->uiProfileIdc = PRO_BASELINE; +#if BUILD_TYPE_TCH + layer->uiLevelIdc = tdav_codec_h264_cisco_convert_level(common->level); +#else + layer->uiLevelIdc = LEVEL_UNKNOWN; // auto-detect +#endif + layer->fFrameRate = self->encoder.sEncParam.fMaxFrameRate; + layer->iMaxSpatialBitrate = self->encoder.sEncParam.iMaxBitrate; + layer->iSpatialBitrate = self->encoder.sEncParam.iTargetBitrate; + layer->iVideoWidth = self->encoder.sEncParam.iPicWidth; + layer->iVideoHeight = self->encoder.sEncParam.iPicHeight; + layer->sSliceCfg.uiSliceMode = SM_DYN_SLICE; + layer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint = H264_RTP_PAYLOAD_SIZE; + layer->sSliceCfg.sSliceArgument.uiSliceNum = 1; + //layer->sSliceCfg.sSliceArgument.uiSliceMbNum[0] = 960; + + if ((err = self->encoder.pInst->InitializeExt(&self->encoder.sEncParam)) != cmResultSuccess) { + TSK_DEBUG_ERROR("InitializeExt failed: %ld", err); + goto bail; + } + + self->encoder.sEncPic.iColorFormat = videoFormatI420; + self->encoder.sEncPic.iPicWidth = self->encoder.sEncParam.iPicWidth; + self->encoder.sEncPic.iPicHeight = self->encoder.sEncParam.iPicHeight; + self->encoder.sEncPic.iStride[0] = self->encoder.sEncPic.iPicWidth; + self->encoder.sEncPic.iStride[1] = self->encoder.sEncPic.iStride[0] >> 1; + self->encoder.sEncPic.iStride[2] = self->encoder.sEncPic.iStride[1]; + + // Create encoder mutex + if (!self->encoder.mutex && !(self->encoder.mutex = tsk_mutex_create())) { + TSK_DEBUG_ERROR("Failed to create mutex for the encoder"); + goto bail; + } + + self->encoder.frame_count = 0; + + ret = 0; + +bail: + return ret; +} + +static int tdav_codec_h264_cisco_close_encoder(tdav_codec_h264_cisco_t* self, tsk_bool_t reset_rotation) +{ + if (self) { + if (self->encoder.pInst) { + self->encoder.pInst->Uninitialize(); + WelsDestroySVCEncoder(self->encoder.pInst); + self->encoder.pInst = NULL; + } + if (self->encoder.buffer) { + TSK_FREE(self->encoder.buffer); + } + if (self->encoder.mutex) { + tsk_mutex_destroy(&self->encoder.mutex); + } + self->encoder.frame_count = 0; + if (reset_rotation) { + self->encoder.rotation = 0; // reset rotation + } + } + return 0; +} + +int tdav_codec_h264_cisco_open_decoder(tdav_codec_h264_cisco_t* self) +{ + int ret = -1; + long err; + tdav_codec_h264_common_t* common = (tdav_codec_h264_common_t*)self; + SDecodingParam sDecParam = { 0 }; + + if (self->decoder.pInst) { + TSK_DEBUG_ERROR("Decoder already initialized"); + goto bail; + } + + // create decoder + if ((err = WelsCreateDecoder(&self->decoder.pInst)) != cmResultSuccess) { + TSK_DEBUG_ERROR("Failed to create decoder: %ld", err); + goto bail; + } + self->decoder.pInst->SetOption(DECODER_OPTION_TRACE_CALLBACK_CONTEXT, self); + self->decoder.pInst->SetOption(DECODER_OPTION_TRACE_CALLBACK, &__tdav_codec_h264_cisco_debug_cb); + + // initialize decoder + sDecParam.iOutputColorFormat = videoFormatI420; + sDecParam.sVideoProperty.eVideoBsType = VIDEO_BITSTREAM_AVC; + if ((err = self->decoder.pInst->Initialize(&sDecParam)) != cmResultSuccess) { + TSK_DEBUG_ERROR("Failed to initialize decoder: %ld", err); + goto bail; + } + self->decoder.last_seq = 0; + TSK_DEBUG_INFO("[OpenH264 Decoder] neg_width=%d, neg_height=%d, neg_fps=%d", + TMEDIA_CODEC_VIDEO(self)->in.width, + TMEDIA_CODEC_VIDEO(self)->in.height, + TMEDIA_CODEC_VIDEO(self)->in.fps + ); + ret = 0; + +bail: + return ret; +} + +static int tdav_codec_h264_cisco_close_decoder(tdav_codec_h264_cisco_t* self) +{ + if (self) { + if (self->decoder.pInst) { + self->decoder.pInst->Uninitialize(); + WelsDestroyDecoder(self->decoder.pInst); + self->decoder.pInst = NULL; + } + TSK_FREE(self->decoder.accumulator); + self->decoder.accumulator_pos = 0; + } + + return 0; +} + +static ELevelIdc tdav_codec_h264_cisco_convert_level(enum level_idc_e level) +{ + switch(level) { + case level_idc_1_0: return LEVEL_1_0; + case level_idc_1_b: return LEVEL_1_B; + case level_idc_1_1: return LEVEL_1_1; + case level_idc_1_2: return LEVEL_1_2; + case level_idc_1_3: return LEVEL_1_3; + case level_idc_2_0: return LEVEL_2_0; + case level_idc_2_1: return LEVEL_2_1; + case level_idc_2_2: return LEVEL_2_2; + case level_idc_3_0: return LEVEL_3_0; + case level_idc_3_1: return LEVEL_3_1; + case level_idc_3_2: return LEVEL_3_2; + case level_idc_4_0: return LEVEL_4_0; + case level_idc_4_1: return LEVEL_4_1; + case level_idc_4_2: return LEVEL_4_2; + case level_idc_5_0: return LEVEL_5_0; + case level_idc_5_1: return LEVEL_5_1; + case level_idc_5_2: return LEVEL_2_2; + default: return LEVEL_UNKNOWN; + } +} + +static void tdav_codec_h264_cisco_debug_cb(void* context, int level, const char* message) +{ + switch (level) { + case WELS_LOG_ERROR: + case WELS_LOG_QUIET: + TSK_DEBUG_ERROR("OpenH264: level=%d, message=%s", level, message); + break; + case WELS_LOG_WARNING: + TSK_DEBUG_WARN("OpenH264: level=%d, message=%s", level, message); + break; + default: + TSK_DEBUG_INFO("OpenH264: level=%d, message=%s", level, message); + break; + } +} + +static int tdav_codec_h264_cisco_init(tdav_codec_h264_cisco_t* self, profile_idc_t profile) +{ + int ret = -1; + level_idc_t level; + tdav_codec_h264_common_t* common = (tdav_codec_h264_common_t*)self; + + if (!self || profile != profile_idc_baseline) { + TSK_DEBUG_ERROR("Invalid parameter"); + goto bail; + } + + if ((ret = tdav_codec_h264_common_init(common))) { + TSK_DEBUG_ERROR("tdav_codec_h264_cisco_common_init() faile with error code=%d", ret); + goto bail; + } + + if ((ret = tdav_codec_h264_common_level_from_size(TMEDIA_CODEC_VIDEO(self)->out.width, TMEDIA_CODEC_VIDEO(self)->out.height, &level))) { + TSK_DEBUG_ERROR("Failed to find level for size=[%u, %u]", TMEDIA_CODEC_VIDEO(self)->out.width, TMEDIA_CODEC_VIDEO(self)->out.height); + goto bail; + } + + common->pack_mode_local = H264_PACKETIZATION_MODE; + common->profile = profile; + common->level = level; + // A.2.1.1 Constrained Baseline profile + // Conformance of a bitstream to the Constrained Baseline profile is indicated by profile_idc being equal to 66 with + // constraint_set1_flag being equal to 1. + common->profile_iop = 0xe0; // "constraint_set0_flag=1 and constraint_set1_flag=1" -> Constrained Baseline profile + TMEDIA_CODEC_VIDEO(self)->in.max_mbps = TMEDIA_CODEC_VIDEO(self)->out.max_mbps = H264_MAX_MBPS*1000; + TMEDIA_CODEC_VIDEO(self)->in.max_br = TMEDIA_CODEC_VIDEO(self)->out.max_br = H264_MAX_BR*1000; + + TMEDIA_CODEC_VIDEO(self)->in.chroma = tmedia_chroma_yuv420p; + TMEDIA_CODEC_VIDEO(self)->out.chroma = tmedia_chroma_yuv420p; + + ret = 0; + +bail: + return ret; +} + +static int tdav_codec_h264_cisco_deinit(tdav_codec_h264_cisco_t* self) +{ + if (!self) { + TSK_DEBUG_ERROR("Invalid parameter"); + return -1; + } + + tdav_codec_h264_cisco_close((tmedia_codec_t*)self); + + return 0; +} + +#endif /* HAVE_OPENH264 */ |
