/* * Copyright (c) 2011 Intel Corporation. All Rights Reserved. * Copyright (c) Imagination Technologies Limited, UK * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) 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 NON-INFRINGEMENT. * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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. * * Authors: * Elaine Wang * Zeng Li * Edward Lin * */ #include #include #include #include #include #include #include "hwdefs/coreflags.h" #include "hwdefs/topaz_vlc_regs.h" #include "hwdefs/topaz_db_regs.h" #include "va/va_enc_h264.h" #include "psb_def.h" #include "psb_drv_debug.h" #include "psb_surface.h" #include "tng_cmdbuf.h" #include "tng_hostcode.h" #include "tng_hostheader.h" #include "tng_picmgmt.h" #include "tng_slotorder.h" #include "tng_hostair.h" #include "tng_H264ES.h" #ifdef _TOPAZHP_PDUMP_ #include "tng_trace.h" #endif #define TOPAZ_H264_MAX_BITRATE 135000000 #define INIT_CONTEXT_H264ES context_ENC_p ctx = (context_ENC_p) obj_context->format_data #define SURFACE(id) ((object_surface_p) object_heap_lookup( &ctx->obj_context->driver_data->surface_heap, id )) #define BUFFER(id) ((object_buffer_p) object_heap_lookup( &ctx->obj_context->driver_data->buffer_heap, id )) static VAStatus tng__H264ES_init_profile( object_context_p obj_context, object_config_p obj_config) { VAStatus vaStatus = VA_STATUS_SUCCESS; context_ENC_p ctx; ctx = (context_ENC_p) obj_context->format_data; switch (obj_config->profile) { case VAProfileH264Baseline: case VAProfileH264ConstrainedBaseline: ctx->ui8ProfileIdc = H264ES_PROFILE_BASELINE; break; case VAProfileH264Main: ctx->ui8ProfileIdc = H264ES_PROFILE_MAIN; break; case VAProfileH264High: ctx->ui8ProfileIdc = H264ES_PROFILE_HIGH; break; case VAProfileH264StereoHigh: ctx->ui8ProfileIdc = H264ES_PROFILE_HIGH; ctx->bEnableMVC = 1; ctx->ui16MVCViewIdx = 0; break; default: ctx->ui8ProfileIdc = H264ES_PROFILE_BASELINE; vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE; break; } drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: obj_config->profile = %dctx->eStandard = %d, ctx->bEnableMVC = %d\n", __FUNCTION__, obj_config->profile, ctx->eStandard, ctx->bEnableMVC); return vaStatus; } static VAStatus tng__H264ES_get_codec_type( object_context_p obj_context, object_config_p __maybe_unused obj_config) { VAStatus vaStatus = VA_STATUS_SUCCESS; context_ENC_p ctx = (context_ENC_p) obj_context->format_data; IMG_RC_PARAMS *psRCParams = &(ctx->sRCParams); ctx->eCodec = IMG_CODEC_NUM; if (ctx->bEnableMVC) { switch (psRCParams->eRCMode) { case IMG_RCMODE_NONE: ctx->eCodec = IMG_CODEC_H264MVC_NO_RC; break; case IMG_RCMODE_CBR: ctx->eCodec = IMG_CODEC_H264MVC_CBR; break; case IMG_RCMODE_VBR: ctx->eCodec = IMG_CODEC_H264MVC_VBR; break; default: drv_debug_msg(VIDEO_DEBUG_ERROR, "RC mode MVC\n"); break; } } else { switch (psRCParams->eRCMode) { case IMG_RCMODE_NONE: ctx->eCodec = IMG_CODEC_H264_NO_RC; break; case IMG_RCMODE_CBR: ctx->eCodec = IMG_CODEC_H264_CBR; break; case IMG_RCMODE_VBR: ctx->eCodec = IMG_CODEC_H264_VBR; break; case IMG_RCMODE_VCM: ctx->eCodec = IMG_CODEC_H264_VCM; break; default: drv_debug_msg(VIDEO_DEBUG_ERROR, "RC mode\n"); break; } } return vaStatus; } static VAStatus tng__H264ES_init_format_mode( object_context_p obj_context, object_config_p __maybe_unused obj_config) { VAStatus vaStatus = VA_STATUS_SUCCESS; context_ENC_p ctx = (context_ENC_p) obj_context->format_data; ctx->bIsInterlaced = IMG_FALSE; ctx->bIsInterleaved = IMG_FALSE; ctx->ui16PictureHeight = ctx->ui16FrameHeight; ctx->eCodec = IMG_CODEC_H264_NO_RC; return vaStatus; } static void tng__H264ES_init_context(object_context_p obj_context, object_config_p __maybe_unused obj_config) { context_ENC_p ctx = (context_ENC_p) obj_context->format_data; //This parameter need not be exposed ctx->ui8InterIntraIndex = 3; ctx->ui8CodedSkippedIndex = 3; ctx->bEnableHostQP = IMG_FALSE; ctx->uMaxChunks = 0xA0; ctx->uChunksPerMb = 0x40; ctx->uPriorityChunks = (0xA0 - 0x60); ctx->ui32FCode = 4; ctx->iFineYSearchSize = 2; //This parameter need not be exposed //host to control the encoding process ctx->bEnableInpCtrl = IMG_FALSE; ctx->bEnableHostBias = IMG_FALSE; //By default false Newly Added ctx->bEnableCumulativeBiases = IMG_FALSE; //Weighted Prediction is not supported in TopazHP Version 3.0 ctx->bWeightedPrediction = IMG_FALSE; ctx->ui8VPWeightedImplicitBiPred = 0; ctx->bInsertHRDParams = IMG_FALSE; ctx->bArbitrarySO = IMG_FALSE; ctx->ui32BasicUnit = 0; ctx->idr_force_flag = 0; ctx->bVPAdaptiveRoundingDisable = IMG_FALSE; } static VAStatus tng__H264ES_process_misc_framerate_param(context_ENC_p ctx, object_buffer_p obj_buffer) { VAEncMiscParameterBuffer *pBuffer = (VAEncMiscParameterBuffer *) obj_buffer->buffer_data; VAEncMiscParameterFrameRate *psMiscFrameRateParam; IMG_RC_PARAMS *psRCParams = &(ctx->sRCParams); ASSERT(obj_buffer->type == VAEncMiscParameterTypeFrameRate); ASSERT(obj_buffer->size == sizeof(VAEncMiscParameterFrameRate)); psMiscFrameRateParam = (VAEncMiscParameterFrameRate *)(pBuffer->data); if (psMiscFrameRateParam == NULL) return VA_STATUS_ERROR_INVALID_BUFFER; if (psMiscFrameRateParam->framerate < 1 || psMiscFrameRateParam->framerate > 65535) return VA_STATUS_ERROR_INVALID_PARAMETER; if (psRCParams->ui32FrameRate == 0) psRCParams->ui32FrameRate = psMiscFrameRateParam->framerate; else { if(psMiscFrameRateParam->framerate != psRCParams->ui32FrameRate){ if (psMiscFrameRateParam->framerate > psRCParams->ui32FrameRate) psRCParams->ui32BitsPerSecond /= (float)psMiscFrameRateParam->framerate / psRCParams->ui32FrameRate; else psRCParams->ui32BitsPerSecond *= (float)psRCParams->ui32FrameRate / psMiscFrameRateParam->framerate; psRCParams->ui32FrameRate = psMiscFrameRateParam->framerate; ctx->rc_update_flag |= RC_MASK_frame_rate; } } return VA_STATUS_SUCCESS; } static VAStatus tng__H264ES_process_misc_ratecontrol_param(context_ENC_p ctx, object_buffer_p obj_buffer) { IMG_INT32 ui32BitsPerFrame; VAEncMiscParameterRateControl *psMiscRcParams; IMG_RC_PARAMS *psRCParams = &(ctx->sRCParams); VAEncMiscParameterBuffer *pBuffer = (VAEncMiscParameterBuffer *) obj_buffer->buffer_data; unsigned int max_bps; ASSERT(obj_buffer->type == VAEncMiscParameterTypeRateControl); ASSERT(obj_buffer->size == sizeof(VAEncMiscParameterRateControl)); psMiscRcParams = (VAEncMiscParameterRateControl *)pBuffer->data; #ifdef _TOPAZHP_PDUMP_ tng_H264ES_trace_misc_rc_params(psMiscRcParams); #endif drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s psRCParams->ui32BitsPerSecond = %d, psMiscRcParams->bits_per_second = %d \n", __FUNCTION__, psRCParams->ui32BitsPerSecond, psMiscRcParams->bits_per_second); if (psMiscRcParams->bits_per_second > TOPAZ_H264_MAX_BITRATE) { drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: bits_per_second(%d) exceeds the maximum bitrate, set it with %d\n", __FUNCTION__, psMiscRcParams->bits_per_second, TOPAZ_H264_MAX_BITRATE); psMiscRcParams->bits_per_second = TOPAZ_H264_MAX_BITRATE; } if ((psRCParams->ui32BitsPerSecond != psMiscRcParams->bits_per_second) && psMiscRcParams->bits_per_second != 0) { psRCParams->ui32BitsPerSecond = psMiscRcParams->bits_per_second; ctx->rc_update_flag |= RC_MASK_bits_per_second; } drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: rate control changed from %d to %d\n", __FUNCTION__, psRCParams->ui32BitsPerSecond, psMiscRcParams->bits_per_second); if (psMiscRcParams->rc_flags.value != 0) { if (psMiscRcParams->rc_flags.bits.disable_bit_stuffing) ctx->sRCParams.bDisableBitStuffing = IMG_TRUE; drv_debug_msg(VIDEO_DEBUG_GENERAL, "bDisableBitStuffing is %d\n", ctx->sRCParams.bDisableBitStuffing); } if (psMiscRcParams->window_size > 2000) { drv_debug_msg(VIDEO_DEBUG_ERROR, "window_size is too much!\n"); return VA_STATUS_ERROR_INVALID_PARAMETER; } if (psMiscRcParams->window_size != 0) ctx->uiCbrBufferTenths = psMiscRcParams->window_size / 100; if (psRCParams->ui32FrameRate == 0) psRCParams->ui32FrameRate = 30; /* According to Table A-1 Level limits, if resolution is bigger than 625SD, min compression ratio is 4, otherwise min compression ratio is 2 */ if (psRCParams->ui32BitsPerSecond == 0) { max_bps = (ctx->obj_context->picture_width * ctx->obj_context->picture_height * 3 / 2 ) * 8 * psRCParams->ui32FrameRate; if (ctx->ui16SourceWidth > 720) max_bps /= 4; else max_bps /= 2; psRCParams->ui32BitsPerSecond = max_bps; } if (ctx->uiCbrBufferTenths) { psRCParams->ui32BufferSize = (IMG_UINT32)(psRCParams->ui32BitsPerSecond * ctx->uiCbrBufferTenths / 10.0); } else { if (psRCParams->ui32BitsPerSecond < 256000) psRCParams->ui32BufferSize = ((9 * psRCParams->ui32BitsPerSecond) >> 1); else psRCParams->ui32BufferSize = ((5 * psRCParams->ui32BitsPerSecond) >> 1); } drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s ctx->uiCbrBufferTenths = %d, psRCParams->ui32BufferSize = %d\n", __FUNCTION__, ctx->uiCbrBufferTenths, psRCParams->ui32BufferSize); drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s psRCParams->ui32BitsPerSecond = %d, psMiscRcParams->bits_per_second = %d\n", __FUNCTION__, psRCParams->ui32BitsPerSecond, psMiscRcParams->bits_per_second); //psRCParams->ui32BUSize = psMiscRcParams->basic_unit_size; psRCParams->i32InitialDelay = (13 * psRCParams->ui32BufferSize) >> 4; psRCParams->i32InitialLevel = (3 * psRCParams->ui32BufferSize) >> 4; ui32BitsPerFrame = psRCParams->ui32BitsPerSecond / psRCParams->ui32FrameRate; /* in order to minimise mismatches between firmware and external world InitialLevel should be a multiple of ui32BitsPerFrame */ psRCParams->i32InitialLevel = ((psRCParams->i32InitialLevel + ui32BitsPerFrame / 2) / ui32BitsPerFrame) * ui32BitsPerFrame; psRCParams->i32InitialLevel = tng__max(psRCParams->i32InitialLevel, ui32BitsPerFrame); psRCParams->i32InitialDelay = psRCParams->ui32BufferSize - psRCParams->i32InitialLevel; //free(psMiscRcParams); if (psMiscRcParams->initial_qp > 51 || psMiscRcParams->min_qp > 51 || psMiscRcParams->max_qp > 51) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Initial_qp(%d) min_qp(%d) max_qp(%d) invalid.\nQP shouldn't be larger than 51 for H264\n", __FUNCTION__, psMiscRcParams->initial_qp, psMiscRcParams->min_qp, psMiscRcParams->max_qp); return VA_STATUS_ERROR_INVALID_PARAMETER; } if ((psRCParams->ui32InitialQp != psMiscRcParams->initial_qp) && (psMiscRcParams->initial_qp != 0)) { drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: initial_qp updated from %d to %d\n", __FUNCTION__, psRCParams->ui32InitialQp, psMiscRcParams->initial_qp); ctx->rc_update_flag |= RC_MASK_initial_qp; psRCParams->ui32InitialQp = psMiscRcParams->initial_qp; } if ((psRCParams->iMinQP != psMiscRcParams->min_qp) && (psMiscRcParams->min_qp != 0)) { drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: min_qp updated from %d to %d\n", __FUNCTION__, psRCParams->iMinQP, psMiscRcParams->min_qp); ctx->rc_update_flag |= RC_MASK_min_qp; psRCParams->iMinQP = psMiscRcParams->min_qp; } if ((ctx->max_qp != psMiscRcParams->max_qp) && (psMiscRcParams->max_qp != 0)) { drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: max_qp updated from %d to %d\n", __FUNCTION__, ctx->max_qp, psMiscRcParams->max_qp); ctx->rc_update_flag |= RC_MASK_max_qp; ctx->max_qp = psMiscRcParams->max_qp; } return VA_STATUS_SUCCESS; } static VAStatus tng__H264ES_process_misc_hrd_param(context_ENC_p ctx, object_buffer_p obj_buffer) { VAStatus vaStatus = VA_STATUS_SUCCESS; VAEncMiscParameterBuffer *pBuffer = (VAEncMiscParameterBuffer *) obj_buffer->buffer_data; VAEncMiscParameterHRD *psMiscHrdParams = NULL; IMG_RC_PARAMS *psRCParams = &(ctx->sRCParams); ASSERT(obj_buffer->type == VAEncMiscParameterTypeHRD); ASSERT(obj_buffer->size == sizeof(VAEncMiscParameterHRD)); psMiscHrdParams = (VAEncMiscParameterHRD *)pBuffer->data; if (psMiscHrdParams->buffer_size == 0 || psMiscHrdParams->initial_buffer_fullness == 0) { drv_debug_msg(VIDEO_DEBUG_ERROR, "Find zero value for buffer_size " "and initial_buffer_fullness.\n"); vaStatus = VA_STATUS_ERROR_INVALID_PARAMETER; return vaStatus; } if (ctx->initial_buffer_fullness > ctx->buffer_size) { drv_debug_msg(VIDEO_DEBUG_ERROR, "initial_buffer_fullnessi(%d) shouldn't be" " larger that buffer_size(%d)!\n", psMiscHrdParams->initial_buffer_fullness, psMiscHrdParams->buffer_size); vaStatus = VA_STATUS_ERROR_INVALID_PARAMETER; return vaStatus; } if (!psRCParams->bRCEnable) { drv_debug_msg(VIDEO_DEBUG_ERROR, "Only when rate control is enabled," " VAEncMiscParameterTypeHRD will take effect.\n"); vaStatus = VA_STATUS_ERROR_ATTR_NOT_SUPPORTED; return vaStatus; } ctx->buffer_size = psMiscHrdParams->buffer_size; ctx->initial_buffer_fullness = psMiscHrdParams->initial_buffer_fullness; ctx->bInsertHRDParams = IMG_TRUE; drv_debug_msg(VIDEO_DEBUG_GENERAL, "hrd param buffer_size set to %d " "initial buffer fullness set to %d\n", ctx->buffer_size, ctx->initial_buffer_fullness); return VA_STATUS_SUCCESS; } //APP_SetVideoParams static VAStatus tng__H264ES_process_misc_air_param(context_ENC_p ctx, object_buffer_p obj_buffer) { VAEncMiscParameterBuffer *pBuffer = (VAEncMiscParameterBuffer *) obj_buffer->buffer_data; VAEncMiscParameterAIR *psMiscAirParams = NULL; ADAPTIVE_INTRA_REFRESH_INFO_TYPE *psAIRInfo = &(ctx->sAirInfo); IMG_UINT32 ui32MbNum; ASSERT(obj_buffer->type == VAEncMiscParameterTypeAIR); ASSERT(obj_buffer->size == sizeof(VAEncMiscParameterAIR)); psMiscAirParams = (VAEncMiscParameterAIR*)pBuffer->data; ui32MbNum = (ctx->ui16PictureHeight * ctx->ui16Width) >> 8; drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: enable_AIR = %d, mb_num = %d, thresh_hold = %d, air_auto = %d\n", __FUNCTION__, ctx->bEnableAIR, psMiscAirParams->air_num_mbs, psMiscAirParams->air_threshold, psMiscAirParams->air_auto); ctx->bEnableAIR = 1; ctx->bEnableInpCtrl = 1; ctx->bEnableHostBias = 1; ctx->ui8EnableSelStatsFlags |= ESF_FIRST_STAGE_STATS; ctx->ui8EnableSelStatsFlags |= ESF_MP_BEST_MB_DECISION_STATS; /*FIXME if (psMiscAirParams->air_threshold == -1 && psMiscAirParams->air_num_mbs == 0) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: ERROR: Cannot have both -AIRMBperFrame set to zero" "AND and -AIRSADThreshold set to -1 (APP_SetVideoParams)\n", __FUNCTION__); return VA_STATUS_ERROR_INVALID_PARAMETER; }*/ if (psMiscAirParams->air_num_mbs > 65535) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: ERROR: air_num_mbs = %d should not bigger than 65536\n", __FUNCTION__, psMiscAirParams->air_num_mbs); return VA_STATUS_ERROR_INVALID_PARAMETER; } if (psMiscAirParams->air_num_mbs > ui32MbNum) psMiscAirParams->air_num_mbs = ui32MbNum; if (psMiscAirParams->air_threshold > 65535) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: ERROR: air_threshold = %d should not bigger than 65536\n", __FUNCTION__, psMiscAirParams->air_threshold); return VA_STATUS_ERROR_INVALID_PARAMETER; } if (psMiscAirParams->air_auto) { psAIRInfo->i32NumAIRSPerFrame = -1; psAIRInfo->i32SAD_Threshold = -1; psAIRInfo->i16AIRSkipCnt = -1; } else { psAIRInfo->i32NumAIRSPerFrame = psMiscAirParams->air_num_mbs; psAIRInfo->i32SAD_Threshold = psMiscAirParams->air_threshold; psAIRInfo->i16AIRSkipCnt = -1; } psAIRInfo->ui16AIRScanPos = 0; drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: air slice size changed to num_air_mbs %d " "air_threshold %d, air_auto %d\n", __FUNCTION__, psMiscAirParams->air_num_mbs, psMiscAirParams->air_threshold, psMiscAirParams->air_auto); if (psAIRInfo->pi8AIR_Table != NULL) free(psAIRInfo->pi8AIR_Table); tng_air_buf_create(ctx); return VA_STATUS_SUCCESS; } static VAStatus tng__H264ES_process_misc_cir_param(context_ENC_p ctx, object_buffer_p obj_buffer) { VAEncMiscParameterBuffer *pBuffer = (VAEncMiscParameterBuffer *)obj_buffer->buffer_data; VAEncMiscParameterCIR *psMiscCirParams = NULL; ASSERT(obj_buffer->type == VAEncMiscParameterTypeCIR); ASSERT(obj_buffer->size == sizeof(VAEncMiscParameterCIR)); psMiscCirParams = (VAEncMiscParameterCIR*)pBuffer->data; if (psMiscCirParams->cir_num_mbs > 0) { drv_debug_msg(VIDEO_DEBUG_GENERAL, "CIR enabled with MB count %d\n", ctx->ui16IntraRefresh); ctx->ui16IntraRefresh = psMiscCirParams->cir_num_mbs; ctx->bEnableCIR = 1; ctx->bEnableInpCtrl = 1; ctx->bEnableHostBias = 1; } else { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: ERROR: invalid cir num mbs(%d), should bigger than 0\n", __FUNCTION__, ctx->ui16IntraRefresh); return VA_STATUS_ERROR_INVALID_PARAMETER; } return VA_STATUS_SUCCESS; } static IMG_UINT8 tng__H264ES_calculate_level(context_ENC_p ctx) { IMG_RC_PARAMS *psRCParams = &(ctx->sRCParams); IMG_UINT32 ui32MBf=0; IMG_UINT32 ui32MBs; IMG_UINT32 ui32Level=0; IMG_UINT32 ui32TempLevel=0; IMG_UINT32 ui32DpbMbs; // We need to calculate the level based on a few constraints these are // Macroblocks per second // picture size // decoded picture buffer size, and bitrate ui32MBf = (ctx->ui16Width)*(ctx->ui16FrameHeight) >> 8; ui32MBs = ui32MBf * psRCParams->ui32FrameRate; // could do these in nice tables, but this is clearer if (ui32MBf > 22080) ui32Level = SH_LEVEL_51; else if (ui32MBf > 8704) ui32Level = SH_LEVEL_50; else if (ui32MBf > 8192) ui32Level = SH_LEVEL_42; else if (ui32MBf > 5120) ui32Level = SH_LEVEL_40; else if (ui32MBf > 3600) ui32Level = SH_LEVEL_32; else if (ui32MBf > 1620) ui32Level = SH_LEVEL_31; else if (ui32MBf > 792) ui32Level = SH_LEVEL_22; else if (ui32MBf > 396) ui32Level = SH_LEVEL_21; else if (ui32MBf > 99) ui32Level = SH_LEVEL_11; else ui32Level = SH_LEVEL_10; drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: ui32MBf = %d, ui32MBs = %d, ui32Level = %d\n", __FUNCTION__, ui32MBf, ui32MBs, ui32Level); //ui32DpbMbs = ui32MBf * (psContext->ui32MaxNumRefFrames + 1); ui32DpbMbs = ui32MBf * (ctx->ui8MaxNumRefFrames + 1); if (ui32DpbMbs > 110400) ui32TempLevel = SH_LEVEL_51; else if (ui32DpbMbs > 34816) ui32TempLevel = SH_LEVEL_50; else if (ui32DpbMbs > 32768) ui32TempLevel = SH_LEVEL_42; else if (ui32DpbMbs > 20480) ui32TempLevel = SH_LEVEL_40; else if (ui32DpbMbs > 18000) ui32TempLevel = SH_LEVEL_32; else if (ui32DpbMbs > 8100) ui32TempLevel = SH_LEVEL_31; else if (ui32DpbMbs > 4752) ui32TempLevel = SH_LEVEL_22; else if (ui32DpbMbs > 2376) ui32TempLevel = SH_LEVEL_21; else if (ui32DpbMbs > 900) ui32TempLevel = SH_LEVEL_12; else if (ui32DpbMbs > 396) ui32TempLevel = SH_LEVEL_11; else ui32TempLevel = SH_LEVEL_10; ui32Level = tng__max(ui32Level, ui32TempLevel); drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: ui32DpbMbs = %d, ui32Level = %d\n", __FUNCTION__, ui32DpbMbs, ui32Level); // now restrict based on the number of macroblocks per second if (ui32MBs > 589824) ui32TempLevel = SH_LEVEL_51; else if (ui32MBs > 522240) ui32TempLevel = SH_LEVEL_50; else if (ui32MBs > 245760) ui32TempLevel = SH_LEVEL_42; else if (ui32MBs > 216000) ui32TempLevel = SH_LEVEL_40; else if (ui32MBs > 108000) ui32TempLevel = SH_LEVEL_32; else if (ui32MBs > 40500) ui32TempLevel = SH_LEVEL_31; else if (ui32MBs > 20250) ui32TempLevel = SH_LEVEL_30; else if (ui32MBs > 19800) ui32TempLevel = SH_LEVEL_22; else if (ui32MBs > 11880) ui32TempLevel = SH_LEVEL_21; else if (ui32MBs > 6000) ui32TempLevel = SH_LEVEL_13; else if (ui32MBs > 3000) ui32TempLevel = SH_LEVEL_12; else if (ui32MBs > 1485) ui32TempLevel = SH_LEVEL_11; else ui32TempLevel = SH_LEVEL_10; ui32Level = tng__max(ui32Level, ui32TempLevel); drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: ui32TempLevel = %d, ui32Level = %d\n", __FUNCTION__, ui32TempLevel, ui32Level); if (psRCParams->bRCEnable) { // now restrict based on the requested bitrate if (psRCParams->ui32FrameRate > 135000000) ui32TempLevel = SH_LEVEL_51; else if (psRCParams->ui32FrameRate > 50000000) ui32TempLevel = SH_LEVEL_50; else if (psRCParams->ui32FrameRate > 20000000) ui32TempLevel = SH_LEVEL_41; else if (psRCParams->ui32FrameRate > 14000000) ui32TempLevel = SH_LEVEL_32; else if (psRCParams->ui32FrameRate > 10000000) ui32TempLevel = SH_LEVEL_31; else if (psRCParams->ui32FrameRate > 4000000) ui32TempLevel = SH_LEVEL_30; else if (psRCParams->ui32FrameRate > 2000000) ui32TempLevel = SH_LEVEL_21; else if (psRCParams->ui32FrameRate > 768000) ui32TempLevel = SH_LEVEL_20; else if (psRCParams->ui32FrameRate > 384000) ui32TempLevel = SH_LEVEL_13; else if (psRCParams->ui32FrameRate > 192000) ui32TempLevel = SH_LEVEL_12; else if (psRCParams->ui32FrameRate > 128000) ui32TempLevel = SH_LEVEL_11; else if (psRCParams->ui32FrameRate > 64000) ui32TempLevel = SH_LEVEL_1B; else ui32TempLevel = SH_LEVEL_10; ui32Level = tng__max(ui32Level, ui32TempLevel); } /* if (pParams->bLossless) { ui32Level = tng__max(ui32Level, 320); } */ drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: target level is %d, input level is %d\n", __FUNCTION__, ui32Level, ctx->ui8LevelIdc); return (IMG_UINT8)ui32Level; } static VAStatus tng__H264ES_process_sequence_param(context_ENC_p ctx, object_buffer_p obj_buffer) { VAStatus vaStatus = VA_STATUS_SUCCESS; VAEncSequenceParameterBufferH264 *psSeqParams; H264_CROP_PARAMS* psCropParams = &(ctx->sCropParams); IMG_RC_PARAMS *psRCParams = &(ctx->sRCParams); FRAME_ORDER_INFO *psFrameInfo = &(ctx->sFrameOrderInfo); H264_VUI_PARAMS *psVuiParams = &(ctx->sVuiParams); IMG_UINT32 ui32MaxUnit32 = (IMG_UINT32)0x7ffa; IMG_UINT32 ui32IPCount = 0; IMG_UINT64 ui64Temp = 0; ASSERT(obj_buffer->type == VAEncSequenceParameterBufferType); ASSERT(obj_buffer->size == sizeof(VAEncSequenceParameterBufferH264)); if (obj_buffer->size != sizeof(VAEncSequenceParameterBufferH264)) { vaStatus = VA_STATUS_ERROR_UNKNOWN; goto out1; } ctx->obj_context->frame_count = 0; psSeqParams = (VAEncSequenceParameterBufferH264 *) obj_buffer->buffer_data; obj_buffer->buffer_data = NULL; obj_buffer->size = 0; #ifdef _TOPAZHP_PDUMP_ tng_H264ES_trace_seq_params(psSeqParams); #endif ctx->ui8LevelIdc = psSeqParams->level_idc; ctx->ui8MaxNumRefFrames = psSeqParams->max_num_ref_frames; ctx->ui32IdrPeriod = psSeqParams->intra_idr_period; ctx->ui32IntraCnt = psSeqParams->intra_period; ui32IPCount = (IMG_UINT32)(psSeqParams->ip_period); if ((ui32IPCount > 4) || (ui32IPCount == 0)) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: ip_period %d, it should be in [1, 4]\n", __FUNCTION__, psSeqParams->ip_period); vaStatus = VA_STATUS_ERROR_INVALID_PARAMETER; goto out1; } if (ctx->ui32IntraCnt == 0) { if (ui32IPCount == 1) ctx->ui32IntraCnt = INT_MAX; else ctx->ui32IntraCnt = INT_MAX - (INT_MAX % ui32IPCount); ctx->ui32IdrPeriod = 1; } else if (ctx->ui32IntraCnt == 1) { //only I frame or IDR frames; ui32IPCount = 1; if (ctx->ui32IdrPeriod == 0) ctx->ui32IdrPeriod = INT_MAX; } else { if (ctx->ui32IdrPeriod == 0) { ctx->ui32IdrPeriod = INT_MAX / ctx->ui32IntraCnt; } else if (ctx->ui32IdrPeriod > 1) { ui64Temp = (IMG_UINT64)(ctx->ui32IdrPeriod) * (IMG_UINT64)(ctx->ui32IntraCnt); if (ui64Temp >= (IMG_UINT64)INT_MAX) { ctx->ui32IdrPeriod = INT_MAX / ctx->ui32IntraCnt; } } if ((ctx->ui32IntraCnt % ui32IPCount) != 0) { if (ctx->ui32IntraCnt > INT_MAX - ui32IPCount + (ctx->ui32IntraCnt % ui32IPCount)) ctx->ui32IntraCnt = INT_MAX - ui32IPCount + (ctx->ui32IntraCnt % ui32IPCount); else ctx->ui32IntraCnt += ui32IPCount - (ctx->ui32IntraCnt % ui32IPCount); } } if (ctx->ui32FrameCount[ctx->ui32StreamID] > 0) { ctx->idr_force_flag = 1; if (ctx->ui32IntraCntSave != ctx->ui32IntraCnt) { drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: intra_period updated from %d to %d\n", __FUNCTION__, ctx->ui32IntraCntSave, ctx->ui32IntraCnt); ctx->rc_update_flag |= RC_MASK_intra_period; } } ctx->ui32IntraCntSave = ctx->ui32IntraCnt; ctx->ui8SlotsInUse = ui32IPCount + 1; //Bframes + 2 //bits per second if (!psSeqParams->bits_per_second) { psSeqParams->bits_per_second = ctx->ui16Width * ctx->ui16PictureHeight * 30 * 12; } if (psSeqParams->bits_per_second > TOPAZ_H264_MAX_BITRATE) { psSeqParams->bits_per_second = TOPAZ_H264_MAX_BITRATE; drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: bits_per_second(%d) exceeds the maximum bitrate, set it with %d\n", __FUNCTION__, psSeqParams->bits_per_second, TOPAZ_H264_MAX_BITRATE); } if (psRCParams->ui32BitsPerSecond == 0) psRCParams->ui32BitsPerSecond = psSeqParams->bits_per_second; if (psSeqParams->bits_per_second != psRCParams->ui32BitsPerSecond) { psRCParams->ui32BitsPerSecond = psSeqParams->bits_per_second; ctx->rc_update_flag |= RC_MASK_bits_per_second; } psRCParams->ui32IntraFreq = ctx->ui32IntraCnt; psRCParams->ui32TransferBitsPerSecond = psRCParams->ui32BitsPerSecond; psRCParams->ui16BFrames = ui32IPCount - 1; if (psRCParams->ui32FrameRate == 0) psRCParams->ui32FrameRate = 30; //set the B frames if (psRCParams->eRCMode == IMG_RCMODE_VCM) psRCParams->ui16BFrames = 0; if ((psRCParams->ui16BFrames > 0) && (ctx->ui8ProfileIdc == H264ES_PROFILE_BASELINE)) { ctx->ui8ProfileIdc = H264ES_PROFILE_MAIN; } if (psFrameInfo->slot_consume_dpy_order != NULL) free(psFrameInfo->slot_consume_dpy_order); if (psFrameInfo->slot_consume_enc_order != NULL) free(psFrameInfo->slot_consume_enc_order); if (psRCParams->ui16BFrames != 0) { memset(psFrameInfo, 0, sizeof(FRAME_ORDER_INFO)); psFrameInfo->slot_consume_dpy_order = (int *)malloc(ctx->ui8SlotsInUse * sizeof(int)); psFrameInfo->slot_consume_enc_order = (int *)malloc(ctx->ui8SlotsInUse * sizeof(int)); if ((psFrameInfo->slot_consume_dpy_order == NULL) || (psFrameInfo->slot_consume_enc_order == NULL)) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: error malloc slot order array\n", __FUNCTION__); } } //set the crop parameters psCropParams->bClip = psSeqParams->frame_cropping_flag; psCropParams->ui16LeftCropOffset = psSeqParams->frame_crop_left_offset; psCropParams->ui16RightCropOffset = psSeqParams->frame_crop_right_offset; psCropParams->ui16TopCropOffset = psSeqParams->frame_crop_top_offset; psCropParams->ui16BottomCropOffset = psSeqParams->frame_crop_bottom_offset; //set level idc parameter ctx->ui32VertMVLimit = 255 ;//(63.75 in qpel increments) ctx->bLimitNumVectors = IMG_FALSE; if (ctx->ui8LevelIdc == 111) ctx->ui8LevelIdc = SH_LEVEL_1B; ctx->ui8LevelIdc = tng__H264ES_calculate_level(ctx); /*Setting VertMVLimit and LimitNumVectors only for H264*/ if (ctx->ui8LevelIdc >= SH_LEVEL_30) ctx->bLimitNumVectors = IMG_TRUE; else ctx->bLimitNumVectors = IMG_FALSE; if (ctx->ui8LevelIdc >= SH_LEVEL_31) ctx->ui32VertMVLimit = 2047 ;//(511.75 in qpel increments) else if (ctx->ui8LevelIdc >= SH_LEVEL_21) ctx->ui32VertMVLimit = 1023 ;//(255.75 in qpel increments) else if (ctx->ui8LevelIdc >= SH_LEVEL_11) ctx->ui32VertMVLimit = 511 ;//(127.75 in qpel increments) //set VUI info memset(psVuiParams, 0, sizeof(H264_VUI_PARAMS)); if (psSeqParams->time_scale != 0 && psSeqParams->num_units_in_tick != 0 && (psSeqParams->time_scale > psSeqParams->num_units_in_tick)) { psVuiParams->Time_Scale = psSeqParams->time_scale; psVuiParams->num_units_in_tick = psSeqParams->num_units_in_tick; } out1: free(obj_buffer->buffer_data); obj_buffer->buffer_data = NULL; obj_buffer->size = 0; return vaStatus; } #if 0 static VAStatus tng__H264ES_process_picture_param(context_ENC_p ctx, object_buffer_p obj_buffer) { VAStatus vaStatus = VA_STATUS_SUCCESS; context_ENC_mem *ps_mem = &(ctx->ctx_mem[ctx->ui32StreamID]); context_ENC_frame_buf *ps_buf = &(ctx->ctx_frame_buf[ctx->ui32StreamID]); IMG_RC_PARAMS * psRCParams = &(ctx->sRCParams); VAEncPictureParameterBufferH264 *psPicParams; IMG_BOOL bDepViewPPS = IMG_FALSE; drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: start\n",__FUNCTION__); ASSERT(obj_buffer->type == VAEncPictureParameterBufferType); if (obj_buffer->size != sizeof(VAEncPictureParameterBufferH264)) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s L%d Invalid coded buffer handle\n", __FUNCTION__, __LINE__); return VA_STATUS_ERROR_UNKNOWN; } /* Transfer ownership of VAEncPictureParameterBufferH264 data */ psPicParams = (VAEncPictureParameterBufferH264 *) obj_buffer->buffer_data; obj_buffer->buffer_data = NULL; obj_buffer->size = 0; ASSERT(ctx->ui16Width == psPicParams->picture_width); ASSERT(ctx->ui16PictureHeight == psPicParams->picture_height); #ifdef _TOPAZHP_OLD_LIBVA_ ps_buf->ref_surface = SURFACE(psPicParams->ReferenceFrames[0].picture_id); ps_buf->coded_buf = BUFFER(psPicParams->coded_buf); #else { IMG_INT32 i; ps_buf->rec_surface = SURFACE(psPicParams->CurrPic.picture_id); for (i = 0; i < 16; i++) ps_buf->ref_surface[i] = SURFACE(psPicParams->ReferenceFrames[i].picture_id); ps_buf->coded_buf = BUFFER(psPicParams->coded_buf); } #endif if (NULL == ps_buf->coded_buf) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s L%d Invalid coded buffer handle\n", __FUNCTION__, __LINE__); free(psPicParams); return VA_STATUS_ERROR_INVALID_BUFFER; } if ((ctx->bEnableMvc) && (ctx->ui16MVCViewIdx != 0) && (ctx->ui16MVCViewIdx != (IMG_UINT16)(NON_MVC_VIEW))) { bDepViewPPS = IMG_TRUE; } /************* init **************** ctx->bCabacEnabled = psPicParams->pic_fields.bits.entropy_coding_mode_flag; ctx->bH2648x8Transform = psPicParams->pic_fields.bits.transform_8x8_mode_flag; ctx->bH264IntraConstrained = psPicParams->pic_fields.bits.constrained_intra_pred_flag; ctx->bWeightedPrediction = psPicParams->pic_fields.bits.weighted_pred_flag; ctx->ui8VPWeightedImplicitBiPred = psPicParams->pic_fields.bits.weighted_bipred_idc; ctx->bCustomScaling = psPicParams->pic_fields.bits.pic_scaling_matrix_present_flag; ************* set rc params *************/ // ctx->sRCParams.ui32InitialQp = psPicParams->pic_init_qp; // ctx->sRCParams.i8QCPOffset = psPicParams->chroma_qp_index_offset; drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s psRCParams->ui32InitialQp = %d, psRCParams->iMinQP = %d\n", __FUNCTION__, psPicParams->pic_init_qp, psPicParams->chroma_qp_index_offset); tng__H264ES_prepare_picture_header( ps_mem->bufs_pic_template.virtual_addr, 0, //IMG_BOOL bCabacEnabled, ctx->bH2648x8Transform, //IMG_BOOL b_8x8transform, 0, //IMG_BOOL bIntraConstrained, 0, //IMG_INT8 i8CQPOffset, 0, //IMG_BOOL bWeightedPrediction, 0, //IMG_UINT8 ui8WeightedBiPred, 0, //IMG_BOOL bMvcPPS, 0, //IMG_BOOL bScalingMatrix, 0 //IMG_BOOL bScalingLists ); free(psPicParams); /* if (psRCParams->ui16BFrames == 0) { tng_send_codedbuf(ctx, (ctx->obj_context->frame_count&1)); tng_send_source_frame(ctx, (ctx->obj_context->frame_count&1), ctx->obj_context->frame_count); } else tng__H264ES_provide_buffer_for_BFrames(ctx); */ drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: end\n",__FUNCTION__); return vaStatus; } #endif static VAStatus tng__H264ES_process_picture_param_base(context_ENC_p ctx, unsigned char *buf) { VAStatus vaStatus = VA_STATUS_SUCCESS; context_ENC_frame_buf *ps_buf = &(ctx->ctx_frame_buf); VAEncPictureParameterBufferH264 *psPicParams; #ifndef _TNG_FRAMES_ IMG_INT32 i; #endif psPicParams = (VAEncPictureParameterBufferH264 *) buf; #ifdef _TOPAZHP_PDUMP_ tng_H264ES_trace_pic_params(psPicParams); #endif #ifdef _TNG_FRAMES_ ps_buf->rec_surface = SURFACE(psPicParams->CurrPic.picture_id); ps_buf->ref_surface = SURFACE(psPicParams->ReferenceFrames[0].picture_id); ps_buf->ref_surface1 = SURFACE(psPicParams->ReferenceFrames[1].picture_id); drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: psPicParams->coded_buf = 0x%08x, ps_buf->coded_buf = 0x%08x\n", __FUNCTION__, psPicParams->coded_buf, ps_buf->coded_buf); #else { ps_buf->rec_surface = SURFACE(psPicParams->CurrPic.picture_id); for (i = 0; i < 4; i++) { ps_buf->ref_surface[i] = SURFACE(psPicParams->ReferenceFrames[i].picture_id); ps_buf->ref_surface[i]->is_ref_surface = 1; } } #endif ps_buf->coded_buf = BUFFER(psPicParams->coded_buf); if (NULL == ps_buf->coded_buf) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s L%d Invalid coded buffer handle\n", __FUNCTION__, __LINE__); free(psPicParams); return VA_STATUS_ERROR_INVALID_BUFFER; } ctx->bH2648x8Transform = psPicParams->pic_fields.bits.transform_8x8_mode_flag; if ((ctx->bH2648x8Transform == 1) && (ctx->ui8ProfileIdc != H264ES_PROFILE_HIGH)) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s L%d only high profile could set bH2648x8Transform TRUE\n", __FUNCTION__, __LINE__); ctx->bH2648x8Transform = 0; } ctx->bH264IntraConstrained = psPicParams->pic_fields.bits.constrained_intra_pred_flag; if (ctx->bEnableMVC == 1) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s L%d MVC could not set bH264IntraConstrained TRUE\n", __FUNCTION__, __LINE__); ctx->bH264IntraConstrained = 0; } ctx->bCabacEnabled = psPicParams->pic_fields.bits.entropy_coding_mode_flag; ctx->bWeightedPrediction = psPicParams->pic_fields.bits.weighted_pred_flag; ctx->ui8VPWeightedImplicitBiPred = psPicParams->pic_fields.bits.weighted_bipred_idc; /************* init **************** ctx->bCustomScaling = psPicParams->pic_fields.bits.pic_scaling_matrix_present_flag; ************* set rc params *************/ if (ctx->sRCParams.ui32InitialQp == 0) ctx->sRCParams.ui32InitialQp = psPicParams->pic_init_qp; ctx->ui32LastPicture = psPicParams->last_picture; return vaStatus; } static VAStatus tng__H264ES_process_picture_param_mvc(context_ENC_p ctx, unsigned char *buf) { VAStatus vaStatus = VA_STATUS_SUCCESS; VAEncPictureParameterBufferH264_MVC *psPicMvcParams; psPicMvcParams = (VAEncPictureParameterBufferH264_MVC *) buf; ctx->ui16MVCViewIdx = ctx->ui32StreamID = psPicMvcParams->view_id; //vaStatus = tng__H264ES_process_picture_param_base(ctx, (unsigned char*)&(psPicMvcParams->base_picture_param)); return vaStatus; } static VAStatus tng__H264ES_process_picture_param(context_ENC_p ctx, object_buffer_p obj_buffer) { VAStatus vaStatus = VA_STATUS_SUCCESS; ASSERT(obj_buffer->type == VAEncPictureParameterBufferType); drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: ctx->bEnableMVC = %d\n", __FUNCTION__, ctx->bEnableMVC); if (ctx->bEnableMVC) { if (obj_buffer->size != sizeof(VAEncPictureParameterBufferH264_MVC)) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s L%d Invalid picture parameter H264 mvc buffer handle\n", __FUNCTION__, __LINE__); return VA_STATUS_ERROR_UNKNOWN; } vaStatus = tng__H264ES_process_picture_param_mvc(ctx, obj_buffer->buffer_data); } else { if (obj_buffer->size != sizeof(VAEncPictureParameterBufferH264)) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s L%d Invalid picture parameter H264 buffer handle\n", __FUNCTION__, __LINE__); return VA_STATUS_ERROR_UNKNOWN; } vaStatus = tng__H264ES_process_picture_param_base(ctx, obj_buffer->buffer_data); } free(obj_buffer->buffer_data); obj_buffer->buffer_data = NULL; obj_buffer->size = 0; return vaStatus; } static VAStatus tng__H264ES_process_slice_param_mrfld(context_ENC_p ctx, object_buffer_p obj_buffer) { VAStatus vaStatus = VA_STATUS_SUCCESS; VAEncSliceParameterBufferH264 *psSliceParamsH264; unsigned int i; unsigned int uiPreMBAddress = 0; unsigned int uiCurMBAddress = 0; unsigned int uiPreMBNumbers = 0; unsigned int uiCurMBNumbers = 0; unsigned int uiAllMBNumbers = 0; unsigned char ucPreDeblockIdc = 0; unsigned char ucCurDeblockIdc = 0; /* Transfer ownership of VAEncPictureParameterBufferH264 data */ psSliceParamsH264 = (VAEncSliceParameterBufferH264*) obj_buffer->buffer_data; #ifdef _TOPAZHP_PDUMP_ tng_H264ES_trace_slice_params(psSliceParamsH264); #endif ucPreDeblockIdc = psSliceParamsH264->disable_deblocking_filter_idc; for (i = 0; i < obj_buffer->num_elements; i++) { uiCurMBAddress = psSliceParamsH264->macroblock_address; uiCurMBNumbers = psSliceParamsH264->num_macroblocks; if (uiCurMBAddress != uiPreMBAddress + uiPreMBNumbers) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s L%d Error Macroblock Address (%d), address (%d), number (%d)\n", __FUNCTION__, __LINE__, i, psSliceParamsH264->macroblock_address, psSliceParamsH264->num_macroblocks); return VA_STATUS_ERROR_INVALID_PARAMETER; } uiPreMBNumbers = uiCurMBNumbers; uiPreMBAddress = uiCurMBAddress; uiAllMBNumbers += uiCurMBNumbers; ucCurDeblockIdc = psSliceParamsH264->disable_deblocking_filter_idc; if (ucPreDeblockIdc != ucCurDeblockIdc) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s L%d Error Macroblock Address (%d), deblock idc pre (%d), cur (%d)\n", __FUNCTION__, __LINE__, i, ucPreDeblockIdc, ucCurDeblockIdc); return VA_STATUS_ERROR_INVALID_PARAMETER; } psSliceParamsH264++; } if (uiAllMBNumbers != (unsigned int)(((IMG_UINT16)(ctx->ui16Width) * (IMG_UINT16)(ctx->ui16PictureHeight)) >> 8)) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s L%d Error Macroblock all number (%d), (%d)\n", __FUNCTION__, __LINE__, i, uiAllMBNumbers, ((ctx->ui16Width * ctx->ui16PictureHeight) >> 8)); return VA_STATUS_ERROR_INVALID_PARAMETER; } //deblocking behaviour ctx->bArbitrarySO = IMG_FALSE; ctx->ui8DeblockIDC = ucCurDeblockIdc; ctx->ui8SlicesPerPicture = obj_buffer->num_elements; return vaStatus; } static VAStatus tng__H264ES_process_slice_param_mdfld(context_ENC_p ctx, object_buffer_p obj_buffer) { VAStatus vaStatus = VA_STATUS_SUCCESS; VAEncSliceParameterBuffer *psSliceParams = NULL; psSliceParams = (VAEncSliceParameterBuffer*) obj_buffer->buffer_data; //deblocking behaviour ctx->bArbitrarySO = IMG_FALSE; ctx->ui8DeblockIDC = psSliceParams->slice_flags.bits.disable_deblocking_filter_idc; ctx->ui8SlicesPerPicture = obj_buffer->num_elements; return vaStatus; } static VAStatus tng__H264ES_process_misc_max_slice_size_param(context_ENC_p ctx, object_buffer_p obj_buffer) { VAEncMiscParameterBuffer *pBuffer = (VAEncMiscParameterBuffer *) obj_buffer->buffer_data; VAEncMiscParameterMaxSliceSize *psMiscMaxSliceSizeParams = NULL; IMG_RC_PARAMS *psRCParams = &(ctx->sRCParams); ASSERT(obj_buffer->type == VAEncMiscParameterTypeMaxSliceSize); ASSERT(obj_buffer->size == sizeof(VAEncMiscParameterMaxSliceSize)); psMiscMaxSliceSizeParams = (VAEncMiscParameterMaxSliceSize*)pBuffer->data; if (psMiscMaxSliceSizeParams->max_slice_size > 0) { psRCParams->ui32SliceByteLimit = psMiscMaxSliceSizeParams->max_slice_size; drv_debug_msg(VIDEO_DEBUG_GENERAL, "Max slice size is %d\n", psRCParams->ui32SliceByteLimit); } else { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: ERROR: invalid max slice size(%d), should bigger than 0\n", __FUNCTION__, psMiscMaxSliceSizeParams->max_slice_size); psRCParams->ui32SliceByteLimit = 0; return VA_STATUS_ERROR_INVALID_PARAMETER; } return VA_STATUS_SUCCESS; } static VAStatus tng__H264ES_process_slice_param(context_ENC_p ctx, object_buffer_p obj_buffer) { VAStatus vaStatus = VA_STATUS_SUCCESS; ASSERT(obj_buffer->type == VAEncSliceParameterBufferType); /* Prepare InParams for macros of current slice, insert slice header, insert do slice command */ if (obj_buffer->size == sizeof(VAEncSliceParameterBufferH264)) { drv_debug_msg(VIDEO_DEBUG_GENERAL, "Receive VAEncSliceParameterBufferH264 buffer\n"); vaStatus = tng__H264ES_process_slice_param_mrfld(ctx, obj_buffer); } else if (obj_buffer->size == sizeof(VAEncSliceParameterBuffer)) { drv_debug_msg(VIDEO_DEBUG_GENERAL, "Receive VAEncSliceParameterBuffer buffer\n"); vaStatus = tng__H264ES_process_slice_param_mdfld(ctx, obj_buffer); } else { drv_debug_msg(VIDEO_DEBUG_ERROR, "Buffer size(%d) is wrong. It should be %d or %d\n", obj_buffer->size, sizeof(VAEncSliceParameterBuffer), sizeof(VAEncSliceParameterBufferH264)); vaStatus = VA_STATUS_ERROR_INVALID_PARAMETER; } free(obj_buffer->buffer_data); obj_buffer->size = 0; obj_buffer->buffer_data = NULL; return vaStatus; } static VAStatus tng__H264ES_process_misc_param(context_ENC_p ctx, object_buffer_p obj_buffer) { VAStatus vaStatus = VA_STATUS_SUCCESS; VAEncMiscParameterBuffer *pBuffer; ASSERT(obj_buffer->type == VAEncMiscParameterBufferType); ASSERT(ctx != NULL); /* Transfer ownership of VAEncMiscParameterBuffer data */ pBuffer = (VAEncMiscParameterBuffer *) obj_buffer->buffer_data; obj_buffer->size = 0; switch (pBuffer->type) { case VAEncMiscParameterTypeFrameRate: vaStatus = tng__H264ES_process_misc_framerate_param(ctx, obj_buffer); break; case VAEncMiscParameterTypeRateControl: vaStatus = tng__H264ES_process_misc_ratecontrol_param(ctx, obj_buffer); break; case VAEncMiscParameterTypeHRD: vaStatus = tng__H264ES_process_misc_hrd_param(ctx, obj_buffer); break; case VAEncMiscParameterTypeAIR: vaStatus = tng__H264ES_process_misc_air_param(ctx, obj_buffer); break; case VAEncMiscParameterTypeCIR: vaStatus = tng__H264ES_process_misc_cir_param(ctx, obj_buffer); break; case VAEncMiscParameterTypeMaxSliceSize: vaStatus = tng__H264ES_process_misc_max_slice_size_param(ctx, obj_buffer); break; default: break; } free(obj_buffer->buffer_data); obj_buffer->buffer_data = NULL; return vaStatus; } static void tng_H264ES_QueryConfigAttributes( VAProfile __maybe_unused profile, VAEntrypoint __maybe_unused entrypoint, VAConfigAttrib *attrib_list, int num_attribs) { int i; /* RateControl attributes */ for (i = 0; i < num_attribs; i++) { switch (attrib_list[i].type) { case VAConfigAttribRTFormat: break; case VAConfigAttribRateControl: attrib_list[i].value = VA_RC_NONE | VA_RC_CBR | VA_RC_VBR | VA_RC_VCM; break; case VAConfigAttribEncAutoReference: attrib_list[i].value = 1; break; case VAConfigAttribEncMaxRefFrames: attrib_list[i].value = 4; break; default: attrib_list[i].value = VA_ATTRIB_NOT_SUPPORTED; break; } } } static VAStatus tng_H264ES_ValidateConfig( object_config_p obj_config) { int i; /* Check all attributes */ for (i = 0; i < obj_config->attrib_count; i++) { switch (obj_config->attrib_list[i].type) { case VAConfigAttribRTFormat: /* Ignore */ break; case VAConfigAttribRateControl: break; case VAConfigAttribEncAutoReference: break; case VAConfigAttribEncMaxRefFrames: break; default: return VA_STATUS_ERROR_ATTR_NOT_SUPPORTED; } } return VA_STATUS_SUCCESS; } static VAStatus tng_H264ES_setup_profile_features(context_ENC_p ctx) { VAStatus vaStatus = VA_STATUS_SUCCESS; IMG_ENCODE_FEATURES * pEncFeatures = &ctx->sEncFeatures; pEncFeatures->bEnable8x16MVDetect = IMG_TRUE; pEncFeatures->bEnable16x8MVDetect = IMG_TRUE; return vaStatus; } static VAStatus tng_H264ES_CreateContext( object_context_p obj_context, object_config_p obj_config) { VAStatus vaStatus = VA_STATUS_SUCCESS; context_ENC_p ctx; vaStatus = tng_CreateContext(obj_context, obj_config, 0); if (VA_STATUS_SUCCESS != vaStatus) return VA_STATUS_ERROR_ALLOCATION_FAILED; ctx = (context_ENC_p) obj_context->format_data; ctx->eStandard = IMG_STANDARD_H264; tng__H264ES_init_context(obj_context, obj_config); vaStatus = tng__H264ES_init_profile(obj_context, obj_config); if (vaStatus != VA_STATUS_SUCCESS) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: tng__H264ES_init_profile\n", __FUNCTION__); } vaStatus = tng__H264ES_init_format_mode(obj_context, obj_config); if (vaStatus != VA_STATUS_SUCCESS) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: tng__H264ES_init_format_mode\n", __FUNCTION__); } vaStatus = tng__H264ES_get_codec_type(obj_context, obj_config); if (vaStatus != VA_STATUS_SUCCESS) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: tng__H264ES_init_rc_mode\n", __FUNCTION__); } vaStatus = tng_H264ES_setup_profile_features(ctx); if (vaStatus != VA_STATUS_SUCCESS) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: tng__profile_features\n", __FUNCTION__); } vaStatus = tng__patch_hw_profile(ctx); if (vaStatus != VA_STATUS_SUCCESS) { drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: tng__patch_hw_profile\n", __FUNCTION__); } return vaStatus; } static void tng_H264ES_DestroyContext( object_context_p obj_context) { tng_DestroyContext(obj_context, 0); } static VAStatus tng_H264ES_BeginPicture( object_context_p obj_context) { INIT_CONTEXT_H264ES; VAStatus vaStatus = VA_STATUS_SUCCESS; vaStatus = tng_BeginPicture(ctx); return vaStatus; } static VAStatus tng_H264ES_RenderPicture( object_context_p obj_context, object_buffer_p *buffers, int num_buffers) { INIT_CONTEXT_H264ES; VAStatus vaStatus = VA_STATUS_SUCCESS; int i; for (i = 0; i < num_buffers; i++) { object_buffer_p obj_buffer = buffers[i]; drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: type = %d, num = %d\n", __FUNCTION__, obj_buffer->type, num_buffers); switch (obj_buffer->type) { case VAEncSequenceParameterBufferType: drv_debug_msg(VIDEO_DEBUG_GENERAL, "tng_H264_RenderPicture got VAEncSequenceParameterBufferType\n"); vaStatus = tng__H264ES_process_sequence_param(ctx, obj_buffer); DEBUG_FAILURE; break; case VAEncPictureParameterBufferType: drv_debug_msg(VIDEO_DEBUG_GENERAL, "tng_H264_RenderPicture got VAEncPictureParameterBuffer\n"); vaStatus = tng__H264ES_process_picture_param(ctx, obj_buffer); DEBUG_FAILURE; break; case VAEncSliceParameterBufferType: drv_debug_msg(VIDEO_DEBUG_GENERAL, "tng_H264_RenderPicture got VAEncSliceParameterBufferType\n"); vaStatus = tng__H264ES_process_slice_param(ctx, obj_buffer); DEBUG_FAILURE; break; case VAEncMiscParameterBufferType: drv_debug_msg(VIDEO_DEBUG_GENERAL, "tng_H264_RenderPicture got VAEncMiscParameterBufferType\n"); vaStatus = tng__H264ES_process_misc_param(ctx, obj_buffer); DEBUG_FAILURE; break; default: vaStatus = VA_STATUS_ERROR_UNKNOWN; DEBUG_FAILURE; } if (vaStatus != VA_STATUS_SUCCESS) { break; } } return vaStatus; } static VAStatus tng_H264ES_EndPicture( object_context_p obj_context) { INIT_CONTEXT_H264ES; VAStatus vaStatus = VA_STATUS_SUCCESS; vaStatus = tng_EndPicture(ctx); return vaStatus; } struct format_vtable_s tng_H264ES_vtable = { queryConfigAttributes: tng_H264ES_QueryConfigAttributes, validateConfig: tng_H264ES_ValidateConfig, createContext: tng_H264ES_CreateContext, destroyContext: tng_H264ES_DestroyContext, beginPicture: tng_H264ES_BeginPicture, renderPicture: tng_H264ES_RenderPicture, endPicture: tng_H264ES_EndPicture }; /*EOF*/