Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / libavc / 280902e61ff706d111d977e9f76d3ebdc8ca3c54 / . / encoder / ih264e_utils.c
blob: c813f57143d4dbb43fbd28ab13faa1a64c7b06b7 [file] [log] [blame]
/******************************************************************************
*
* Copyright (C) 2015 The Android Open Source Project
*
* 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
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*****************************************************************************
* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
*/
/**
*******************************************************************************
* @file
* ih264e_utils.c
*
* @brief
* Contains miscellaneous utility functions used by the encoder
*
* @author
* ittiam
*
* @par List of Functions:
* - ih264e_get_min_level()
* - ih264e_get_lvl_idx()
* - ih264e_get_dpb_size()
* - ih264e_get_total_pic_buf_size()
* - ih264e_get_pic_mv_bank_size()
* - ih264e_pic_buf_mgr_add_bufs()
* - ih264e_mv_buf_mgr_add_bufs()
* - ih264e_init_quant_params()
* - ih264e_init_air_map()
* - ih264e_codec_init()
* - ih264e_pic_init()
*
* @remarks
* None
*
*******************************************************************************
*/
/*****************************************************************************/
/* File Includes */
/*****************************************************************************/
/* system include files */
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
/* user include files */
#include "ih264_typedefs.h"
#include "iv2.h"
#include "ive2.h"
#include "ih264e.h"
#include "ithread.h"
#include "ih264_defs.h"
#include "ih264_size_defs.h"
#include "ime_distortion_metrics.h"
#include "ime_defs.h"
#include "ime_structs.h"
#include "ih264_error.h"
#include "ih264_structs.h"
#include "ih264_trans_quant_itrans_iquant.h"
#include "ih264_inter_pred_filters.h"
#include "ih264_mem_fns.h"
#include "ih264_padding.h"
#include "ih264_intra_pred_filters.h"
#include "ih264_deblk_edge_filters.h"
#include "ih264_cabac_tables.h"
#include "ih264_macros.h"
#include "ih264_common_tables.h"
#include "ih264_debug.h"
#include "ih264_trans_data.h"
#include "ih264e_defs.h"
#include "ih264e_globals.h"
#include "ih264_buf_mgr.h"
#include "ih264_dpb_mgr.h"
#include "ih264e_error.h"
#include "ih264e_bitstream.h"
#include "irc_cntrl_param.h"
#include "irc_frame_info_collector.h"
#include "ih264e_rate_control.h"
#include "ih264e_cabac_structs.h"
#include "ih264e_structs.h"
#include "ih264e_cabac.h"
#include "ih264e_utils.h"
#include "ih264e_config.h"
#include "ih264e_statistics.h"
#include "ih264e_trace.h"
#include "ih264_list.h"
#include "ih264e_encode_header.h"
#include "ih264e_me.h"
#include "ime.h"
#include "ih264e_core_coding.h"
#include "ih264e_rc_mem_interface.h"
#include "ih264e_time_stamp.h"
#include "ih264e_debug.h"
#include "ih264e_process.h"
#include "ih264e_master.h"
#include "irc_rate_control_api.h"
#include "ime_statistics.h"
/*****************************************************************************/
/* Function Definitions */
/*****************************************************************************/
/**
*******************************************************************************
*
* @brief
* Queues the current buffer, gets back a another buffer for encoding with corrent
* picture type
*
* @par Description:
* This function performs 3 distinct but related functions.
* 1) Maintains an input queue [Note the the term queue donot imply a
* first-in first-out logic here] that queues input and dequeues them so
* that input frames can be encoded at any predetermined encoding order
* 2) Uses RC library to decide which frame must be encoded in current pass
* and which picture type it must be encoded to.
* 3) Uses RC library to decide the QP at which current frame has to be
* encoded
* 4) Determines if the current picture must be encoded or not based on
* PRE-ENC skip
*
* Input queue is used for storing input buffers till they are used for
* encoding. This queue is maintained at ps_codec->as_inp_list. Whenever a
* valid input comes, it is added to the end of queue. This same input is
* added to RC queue using the identifier as ps_codec->i4_pic_cnt. Hence any
* pic from RC can be located in the input queue easily.
*
* The dequeue operation does not start till we have ps_codec->s_cfg.u4_max_num_bframes
* frames in the queue. THis is done in order to ensure that once output starts
* we will have a constant stream of output with no gaps.
*
* THe output frame order is governed by RC library. When ever we dequeue a
* buffer from RC library, it ensures that we will get them in encoding order
* With the output of RC library, we can use the picture id to dequeue the
* corresponding buffer from input queue and encode it.
*
* Condition at the end of stream.
* -------------------------------
* At the last valid buffer from the app, we will get ps_ive_ip->u4_is_last
* to be set. This will the given to lib when appropriate input buffer is
* given to encoding.
*
* Since we have to output is not in sync with input, we will have frames to
* encode even after we recive the last vaild input buffer. Hence we have to
* make sure that we donot queue any new buffers once we get the flag [It may
* mess up GOP ?]. This is acheived by setting ps_codec->i4_last_inp_buff_received
* to act as a permenent marker for last frame recived [This may not be needed,
* because in our current app, all buffers after the last are marked as last.
* But can we rely on that?] . Hence after this flgag is set no new buffers are
* queued.
*
* @param[in] ps_codec
* Pointer to codec descriptor
*
* @param[in] ps_ive_ip
* Current input buffer to the encoder
*
* @param[out] ps_inp
* Buffer to be encoded in the current pass
*
* @returns
* Flag indicating if we have a pre-enc skip or not
*
* @remarks
* TODO (bpic)
* The check for null ans is last is redudent.
* Need to see if we can remove it
*
*******************************************************************************
*/
WORD32 ih264e_input_queue_update(codec_t *ps_codec,
ive_video_encode_ip_t *ps_ive_ip,
inp_buf_t *ps_enc_buff)
{
inp_buf_t *ps_inp_buf;
picture_type_e e_pictype;
WORD32 i4_skip;
UWORD32 ctxt_sel, u4_pic_id, u4_pic_disp_id;
UWORD8 u1_frame_qp, i;
UWORD32 max_frame_bits = 0x7FFFFFFF;
/* Mark that the last input frame has been received */
if (ps_ive_ip->u4_is_last == 1)
{
ps_codec->i4_last_inp_buff_received = 1;
}
if (ps_ive_ip->s_inp_buf.apv_bufs[0] == NULL
&& !ps_codec->i4_last_inp_buff_received)
{
ps_enc_buff->s_raw_buf.apv_bufs[0] = NULL;
ps_enc_buff->u4_is_last = ps_ive_ip->u4_is_last;
return 0;
}
/***************************************************************************
* Check for pre enc skip
* When src and target frame rates donot match, we skip some frames to
* maintain the relation ship between them
**************************************************************************/
{
WORD32 skip_src;
skip_src = ih264e_update_rc_framerates(
ps_codec->s_rate_control.pps_rate_control_api,
ps_codec->s_rate_control.pps_pd_frm_rate,
ps_codec->s_rate_control.pps_time_stamp,
ps_codec->s_rate_control.pps_frame_time);
if (skip_src)
{
ps_enc_buff->u4_is_last = ps_ive_ip->u4_is_last;
return 1;
}
}
/***************************************************************************
*Queue the input to the queue
**************************************************************************/
ps_inp_buf = &(ps_codec->as_inp_list[ps_codec->i4_pic_cnt
% MAX_NUM_INP_FRAMES]);
/* copy input info. to internal structure */
ps_inp_buf->s_raw_buf = ps_ive_ip->s_inp_buf;
ps_inp_buf->u4_timestamp_low = ps_ive_ip->u4_timestamp_low;
ps_inp_buf->u4_timestamp_high = ps_ive_ip->u4_timestamp_high;
ps_inp_buf->u4_is_last = ps_ive_ip->u4_is_last;
ps_inp_buf->pv_mb_info = ps_ive_ip->pv_mb_info;
ps_inp_buf->u4_mb_info_type = ps_ive_ip->u4_mb_info_type;
ps_inp_buf->pv_pic_info = ps_ive_ip->pv_pic_info;
ps_inp_buf->u4_pic_info_type = ps_ive_ip->u4_pic_info_type;
/***************************************************************************
* Now we should add the picture to RC stack here
**************************************************************************/
/*
* If an I frame has been requested, ask RC to force it
* For IDR requests, we have to ask RC to force I and set IDR by our selves
* since RC Donot know about IDR. For forcing an IDR at dequeue stage we
* should record that an IDR has been requested some where. Hence we will
* store it in the u4_idr_inp_list at a position same as that of input frame
*/
{
WORD32 i4_force_idr, i4_force_i;
i4_force_idr = (ps_codec->force_curr_frame_type == IV_IDR_FRAME);
i4_force_idr |= !(ps_codec->i4_pic_cnt % ps_codec->s_cfg.u4_idr_frm_interval);
i4_force_i = (ps_codec->force_curr_frame_type == IV_I_FRAME);
ps_codec->i4_pending_idr_flag |= i4_force_idr;
if ((ps_codec->i4_pic_cnt > 0) && (i4_force_idr || i4_force_i))
{
irc_force_I_frame(ps_codec->s_rate_control.pps_rate_control_api);
}
ps_codec->force_curr_frame_type = IV_NA_FRAME;
}
irc_add_picture_to_stack(ps_codec->s_rate_control.pps_rate_control_api,
ps_codec->i4_pic_cnt);
/* Delay */
if (ps_codec->i4_encode_api_call_cnt
< (WORD32)(ps_codec->s_cfg.u4_num_bframes))
{
ps_enc_buff->s_raw_buf.apv_bufs[0] = NULL;
ps_enc_buff->u4_is_last = 0;
return 0;
}
/***************************************************************************
* Get a new pic to encode
**************************************************************************/
/* Query the picture_type */
e_pictype = ih264e_rc_get_picture_details(
ps_codec->s_rate_control.pps_rate_control_api, (WORD32 *)(&u4_pic_id),
(WORD32 *)(&u4_pic_disp_id));
switch (e_pictype)
{
case I_PIC:
ps_codec->pic_type = PIC_I;
break;
case P_PIC:
ps_codec->pic_type = PIC_P;
break;
case B_PIC:
ps_codec->pic_type = PIC_B;
break;
default:
ps_codec->pic_type = PIC_NA;
ps_enc_buff->s_raw_buf.apv_bufs[0] = NULL;
return 0;
}
/* Set IDR if it has been requested */
if (ps_codec->pic_type == PIC_I)
{
ps_codec->pic_type = ps_codec->i4_pending_idr_flag ?
PIC_IDR : ps_codec->pic_type;
ps_codec->i4_pending_idr_flag = 0;
}
/* Get current frame Qp */
u1_frame_qp = (UWORD8)irc_get_frame_level_qp(
ps_codec->s_rate_control.pps_rate_control_api, e_pictype,
max_frame_bits);
ps_codec->u4_frame_qp = gau1_mpeg2_to_h264_qmap[u1_frame_qp];
/*
* copy the pic id to poc because the display order is assumed to be same
* as input order
*/
ps_codec->i4_poc = u4_pic_id;
/***************************************************************************
* Now retrieve the correct picture from the queue
**************************************************************************/
/* Mark the skip flag */
i4_skip = 0;
ctxt_sel = ps_codec->i4_encode_api_call_cnt % MAX_CTXT_SETS;
ps_codec->s_rate_control.pre_encode_skip[ctxt_sel] = i4_skip;
/* Get a buffer to encode */
ps_inp_buf = &(ps_codec->as_inp_list[u4_pic_id % MAX_NUM_INP_FRAMES]);
/* copy dequeued input to output */
ps_enc_buff->s_raw_buf = ps_inp_buf->s_raw_buf;
ps_enc_buff->u4_timestamp_low = ps_inp_buf->u4_timestamp_low;
ps_enc_buff->u4_timestamp_high = ps_inp_buf->u4_timestamp_high;
ps_enc_buff->u4_is_last = ps_inp_buf->u4_is_last;
ps_enc_buff->pv_mb_info = ps_inp_buf->pv_mb_info;
ps_enc_buff->u4_mb_info_type = ps_inp_buf->u4_mb_info_type;
ps_enc_buff->pv_pic_info = ps_inp_buf->pv_pic_info;
ps_enc_buff->u4_pic_info_type = ps_inp_buf->u4_pic_info_type;
/* Special case for encoding trailing B frames
*
* In encoding streams with B frames it may happen that we have a B frame
* at the end without a P/I frame after it. Hence when we are dequeing from
* the RC, it will return the P frame [next in display order but before in
* encoding order] first. Since the dequeue happens for an invalid frame we
* will get a frame with null buff and set u4_is_last. Hence lib with return
* last frame flag at this point and will stop encoding.
*
* Since for the last B frame, we does not have the forward ref frame
* it makes sense to force it into P.
*
* To solve this, in case the current frame is P and if the last frame flag
* is set, we need to see if there is and pending B frames. If there are any,
* we should just encode that picture as the current P frame and set
* that B frame as the last frame. Hence the encoder will terminate naturally
* once that B-frame is encoded after all the in between frames.
*
* Since we cannot touch RC stack directly, the option of actually swapping
* frames in RC is ruled out. We have to modify the as_inp_list to simulate
* such a behavior by RC. We can do that by
* 1) Search through as_inp_list to locate the largest u4_timestamp_low less
* than current u4_timestamp_low. This will give us the last B frame before
* the current P frame. Note that this will handle pre encode skip too since
* queue happens after pre enc skip.
* 2) Swap the position in as_inp_list. Hence now the last B frame is
* encoded as P frame. And the new last B frame will have u4_is_last
* set so that encoder will end naturally once we reached that B frame
* or any subsequent frame. Also the current GOP will have 1 less B frame
* Since we are swapping, the poc will also be in-order.
* 3) In case we have an IPP stream, the result of our search will be an
* I/P frame which is already encoded. Thus swap and encode will result
* in encoding of duplicate frames. Hence to avoid this we will only
* have this work around in case of u4_num_bframes > 0.
*
* In case we have forced an I/IDR frame In between this P frame and
* the last B frame -> This cannot happen as the current P frame is
* supposed to have u4_is_last set. Thus forcing an I/ IDR after this
* is illogical.
*
* In cae if we have forced an I such that the frame just before last frame
* in is I/P -> This case will never arise. Since we have a closed GOP now,
* once we force an I, the gop gets reset, hence there will be a B between
* I/P and I/P.
*/
if (ps_enc_buff->u4_is_last && (ps_codec->pic_type == PIC_P)
&& ps_codec->s_cfg.u4_num_bframes)
{
WORD32 cntr;
WORD32 lst_bframe = -1;
UWORD32 u4_timestamp_low = 0;
UWORD32 u4_timestamp_high = 0;
inp_buf_t *ps_swap_buff, *ps_inp_list;
ps_inp_list = &ps_codec->as_inp_list[0];
/* Now search the inp list for highest timestamp */
for(cntr = 0; cntr < MAX_NUM_INP_FRAMES; cntr++)
{
if(ps_inp_list[cntr].s_raw_buf.apv_bufs[0] != NULL)
{
if ((ps_inp_list[cntr].u4_timestamp_high > u4_timestamp_high) ||
(ps_inp_list[cntr].u4_timestamp_high == u4_timestamp_high &&
ps_inp_list[cntr].u4_timestamp_low > u4_timestamp_low))
{
u4_timestamp_low = ps_inp_list[cntr].u4_timestamp_low;
u4_timestamp_high = ps_inp_list[cntr].u4_timestamp_high;
lst_bframe = cntr;
}
}
}
if(lst_bframe != -1)
{
ps_swap_buff = &(ps_codec->as_inp_list[lst_bframe]);
/* copy the last B buffer to output */
*ps_enc_buff = *ps_swap_buff;
/* Store the current buf into the queue in place of last B buf */
*ps_swap_buff = *ps_inp_buf;
}
}
if (ps_enc_buff->u4_is_last)
{
ps_codec->pic_type = PIC_NA;
}
/* The buffer in the queue is set to NULL to specify that encoding is done for that frame */
for(i = 0; i < 3; i++)
{
ps_inp_buf->s_raw_buf.apv_bufs[i] = NULL;
}
/* Return the buffer status */
return (0);
}
/**
*******************************************************************************
*
* @brief
* Used to get minimum level index for a given picture size
*
* @par Description:
* Gets the minimum level index and then gets corresponding level.
* Also used to ignore invalid levels like 2.3, 3.3 etc
*
* @param[in] level
* Level of the stream
*
* @returns Level index for a given level
*
* @remarks
*
*******************************************************************************
*/
WORD32 ih264e_get_min_level(WORD32 wd, WORD32 ht)
{
WORD32 lvl_idx = MAX_LEVEL, i;
WORD32 pic_size = wd * ht;
WORD32 max = MAX(wd, ht);
for (i = 0; i < MAX_LEVEL; i++)
{
if ((pic_size <= gai4_ih264_max_luma_pic_size[i]) &&
(max <= gai4_ih264_max_wd_ht[i]))
{
lvl_idx = i;
break;
}
}
return gai4_ih264_levels[lvl_idx];
}
/**
*******************************************************************************
*
* @brief
* Used to get level index for a given level
*
* @par Description:
* Converts from level_idc (which is multiplied by 30) to an index that can be
* used as a lookup. Also used to ignore invalid levels like 2.2 , 3.2 etc
*
* @param[in] level
* Level of the stream
*
* @returns Level index for a given level
*
* @remarks
*
*******************************************************************************
*/
WORD32 ih264e_get_lvl_idx(WORD32 level)
{
WORD32 lvl_idx = 0;
if (level < IH264_LEVEL_11)
{
lvl_idx = 0;
}
else if (level < IH264_LEVEL_12)
{
lvl_idx = 1;
}
else if (level < IH264_LEVEL_13)
{
lvl_idx = 2;
}
else if (level < IH264_LEVEL_20)
{
lvl_idx = 3;
}
else if (level < IH264_LEVEL_21)
{
lvl_idx = 4;
}
else if (level < IH264_LEVEL_22)
{
lvl_idx = 5;
}
else if (level < IH264_LEVEL_30)
{
lvl_idx = 6;
}
else if (level < IH264_LEVEL_31)
{
lvl_idx = 7;
}
else if (level < IH264_LEVEL_32)
{
lvl_idx = 8;
}
else if (level < IH264_LEVEL_40)
{
lvl_idx = 9;
}
else if (level < IH264_LEVEL_41)
{
lvl_idx = 10;
}
else if (level < IH264_LEVEL_42)
{
lvl_idx = 11;
}
else if (level < IH264_LEVEL_50)
{
lvl_idx = 12;
}
else if (level < IH264_LEVEL_51)
{
lvl_idx = 13;
}
else
{
lvl_idx = 14;
}
return (lvl_idx);
}
/**
*******************************************************************************
*
* @brief returns maximum number of pictures allowed in dpb for a given level
*
* @par Description:
* For given width, height and level, number of pictures allowed in decoder
* picture buffer is computed as per Annex A.3.1
*
* @param[in] level
* level of the bit-stream
*
* @param[in] pic_size
* width * height
*
* @returns Number of buffers in DPB
*
* @remarks
* From annexure A.3.1 of H264 specification,
* max_dec_frame_buffering <= MaxDpbSize, where MaxDpbSize is equal to
* Min( 1024 * MaxDPB / ( PicWidthInMbs * FrameHeightInMbs * 384 ), 16 ) and
* MaxDPB is given in Table A-1 in units of 1024 bytes. However the MaxDPB size
* presented in the look up table gas_ih264_lvl_tbl is in units of 512
* bytes. Hence the expression is modified accordingly.
*
*******************************************************************************
*/
WORD32 ih264e_get_dpb_size(WORD32 level, WORD32 pic_size)
{
/* dpb size */
WORD32 max_dpb_size_bytes = 0;
/* dec frame buffering */
WORD32 max_dpb_size_frames = 0;
/* temp var */
WORD32 i;
/* determine max luma samples */
for (i = 0; i < 16; i++)
if (level == (WORD32)gas_ih264_lvl_tbl[i].u4_level_idc)
max_dpb_size_bytes = gas_ih264_lvl_tbl[i].u4_max_dpb_size;
/* from Annexure A.3.1 h264 specification */
max_dpb_size_frames =
MIN( 1024 * max_dpb_size_bytes / ( pic_size * 3 ), MAX_DPB_SIZE );
return max_dpb_size_frames;
}
/**
*******************************************************************************
*
* @brief
* Used to get reference picture buffer size for a given level and
* and padding used
*
* @par Description:
* Used to get reference picture buffer size for a given level and padding used
* Each picture is padded on all four sides
*
* @param[in] pic_size
* Number of luma samples (Width * Height)
*
* @param[in] level
* Level
*
* @param[in] horz_pad
* Total padding used in horizontal direction
*
* @param[in] vert_pad
* Total padding used in vertical direction
*
* @returns Total picture buffer size
*
* @remarks
*
*
*******************************************************************************
*/
WORD32 ih264e_get_total_pic_buf_size(WORD32 pic_size,
WORD32 level,
WORD32 horz_pad,
WORD32 vert_pad,
WORD32 num_ref_frames,
WORD32 num_reorder_frames)
{
WORD32 size;
WORD32 num_luma_samples;
WORD32 lvl_idx;
WORD32 max_wd, min_ht;
WORD32 num_samples;
WORD32 max_num_bufs;
WORD32 pad = MAX(horz_pad, vert_pad);
/*
* If num_ref_frames and num_reorder_frmaes is specified
* Use minimum value
*/
max_num_bufs = (num_ref_frames + num_reorder_frames + MAX_CTXT_SETS);
/* Get level index */
lvl_idx = ih264e_get_lvl_idx(level);
/* Maximum number of luma samples in a picture at given level */
num_luma_samples = gai4_ih264_max_luma_pic_size[lvl_idx];
num_luma_samples = MAX(num_luma_samples, pic_size);
/* Account for chroma */
num_samples = num_luma_samples * 3 / 2;
/* Maximum width of luma samples in a picture at given level */
max_wd = gai4_ih264_max_wd_ht[lvl_idx];
/* Minimum height of luma samples in a picture at given level */
min_ht = gai4_ih264_min_wd_ht[lvl_idx];
/* Allocation is required for
* (Wd + horz_pad) * (Ht + vert_pad) * (2 * max_dpb_size + 1)
*
* Above expanded as
* ((Wd * Ht) + (horz_pad * vert_pad) + Wd * vert_pad + Ht * horz_pad) * (2 * max_dpb_size + 1)
* (Wd * Ht) * (2 * max_dpb_size + 1) + ((horz_pad * vert_pad) + Wd * vert_pad + Ht * horz_pad) * (2 * max_dpb_size + 1)
* Now max_dpb_size increases with smaller Wd and Ht, but Wd * ht * max_dpb_size will still be lesser or equal to max_wd * max_ht * dpb_size
*
* In the above equation (Wd * Ht) * (2 * max_dpb_size + 1) is accounted by using num_samples * (2 * max_dpb_size + 1) below
*
* For the padded area use MAX(horz_pad, vert_pad) as pad
* ((pad * pad) + pad * (Wd + Ht)) * (2 * max_dpb_size + 1) has to accounted from the above for padding
*
* Since Width and Height can change worst Wd + Ht is when One of the dimensions is max and other is min
* So use max_wd and min_ht
*/
/* Number of bytes in reference pictures */
size = num_samples * max_num_bufs;
/* Account for padding area */
size += ((pad * pad) + pad * (max_wd + min_ht)) * 3 / 2 * max_num_bufs;
return size;
}
/**
*******************************************************************************
*
* @brief Returns MV bank buffer size for a given number of luma samples
*
* @par Description:
* For given number of luma samples one MV bank size is computed.
* Each MV bank includes pu_map and enc_pu_t for all the min PUs(4x4) in a picture
*
* @param[in] num_luma_samples
* Max number of luma pixels in the frame
*
* @returns Total MV Bank size
*
* @remarks
*
*******************************************************************************
*/
WORD32 ih264e_get_pic_mv_bank_size(WORD32 num_luma_samples)
{
/* mv bank buffer size */
WORD32 mv_bank_size = 0;
/* number of sub mb partitions possible */
WORD32 num_pu = num_luma_samples / (ENC_MIN_PU_SIZE * ENC_MIN_PU_SIZE);
/* number of mbs */
WORD32 num_mb = num_luma_samples / (MB_SIZE * MB_SIZE);
/* Size for storing enc_pu_t start index each MB */
/* One extra entry is needed to compute number of PUs in the last MB */
mv_bank_size += num_mb * sizeof(WORD32);
/* Size for pu_map */
mv_bank_size += ALIGN4(num_pu);
/* Size for storing enc_pu_t for each PU */
mv_bank_size += ALIGN4(num_pu * sizeof(enc_pu_t));
return mv_bank_size;
}
/**
*******************************************************************************
*
* @brief
* Function to initialize ps_pic_buf structs add pic buffers to
* buffer manager in case of non-shared mode
*
* @par Description:
* Function to initialize ps_pic_buf structs add pic buffers to
* buffer manager in case of non-shared mode
* To be called once per stream or for every reset
*
* @param[in] ps_codec
* Pointer to codec context
*
* @returns error status
*
* @remarks
*
*******************************************************************************
*/
IH264E_ERROR_T ih264e_pic_buf_mgr_add_bufs(codec_t *ps_codec)
{
/* error status */
IH264E_ERROR_T ret = IH264E_SUCCESS;
/* max ref buffer cnt */
WORD32 max_num_bufs = ps_codec->i4_ref_buf_cnt;
/* total size for pic buffers */
WORD32 pic_buf_size_allocated = ps_codec->i4_total_pic_buf_size
- BUF_MGR_MAX_CNT * sizeof(pic_buf_t);
/* temp var */
UWORD8 *pu1_buf = (UWORD8 *) ps_codec->ps_pic_buf;
pic_buf_t *ps_pic_buf = (pic_buf_t *) ps_codec->ps_pic_buf;
WORD32 i;
pu1_buf += BUF_MGR_MAX_CNT * sizeof(pic_buf_t);
/* In case of non-shared mode, add picture buffers to buffer manager
* In case of shared mode, buffers are added in the run-time
*/
{
WORD32 buf_ret;
WORD32 luma_samples = (ps_codec->i4_rec_strd)
* (ps_codec->s_cfg.u4_ht + PAD_HT);
WORD32 chroma_samples = luma_samples >> 1;
/* Try and add as many buffers as possible for the memory that is allocated */
/* If the number of buffers that can be added is less than max_num_bufs
* return with an error */
for (i = 0; i < max_num_bufs; i++)
{
pic_buf_size_allocated -= (luma_samples + chroma_samples);
if (pic_buf_size_allocated < 0)
{
ps_codec->i4_error_code = IH264E_INSUFFICIENT_MEM_PICBUF;
return IH264E_INSUFFICIENT_MEM_PICBUF;
}
ps_pic_buf->pu1_luma = pu1_buf + ps_codec->i4_rec_strd * PAD_TOP
+ PAD_LEFT;
pu1_buf += luma_samples;
ps_pic_buf->pu1_chroma = pu1_buf
+ ps_codec->i4_rec_strd * (PAD_TOP / 2)+ PAD_LEFT;
pu1_buf += chroma_samples;
buf_ret = ih264_buf_mgr_add((buf_mgr_t *) ps_codec->pv_ref_buf_mgr,
ps_pic_buf, i);
if (0 != buf_ret)
{
ps_codec->i4_error_code = IH264E_BUF_MGR_ERROR;
return IH264E_BUF_MGR_ERROR;
}
pu1_buf += (HPEL_PLANES_CNT - 1) * (chroma_samples + luma_samples);
ps_pic_buf++;
}
}
return ret;
}
/**
*******************************************************************************
*
* @brief Function to add buffers to MV Bank buffer manager
*
* @par Description:
* Function to add buffers to MV Bank buffer manager. To be called once per
* stream or for every reset
*
* @param[in] ps_codec
* Pointer to codec context
*
* @returns error status
*
* @remarks
*
*******************************************************************************
*/
IH264E_ERROR_T ih264e_mv_buf_mgr_add_bufs(codec_t *ps_codec)
{
/* error status */
IH264E_ERROR_T error_status = IH264E_SUCCESS;
IH264_ERROR_T ret;
/* max dpb size in frames */
WORD32 max_dpb_size = 0;
/* mv bank size for the entire dpb */
WORD32 mv_bank_size_allocated = 0;
/* mv bank size per pic */
WORD32 pic_mv_bank_size = 0;
/* mv buffer ptr */
mv_buf_t *ps_mv_buf = NULL;
/* num of luma samples */
WORD32 num_luma_samples = ALIGN16(ps_codec->s_cfg.u4_wd)
* ALIGN16(ps_codec->s_cfg.u4_ht);
/* number of mb's & frame partitions */
WORD32 num_pu, num_mb;
/* temp var */
UWORD8 *pu1_buf = NULL;
WORD32 i;
/* Compute the number of MB Bank buffers needed */
max_dpb_size = ps_codec->i4_ref_buf_cnt;
/* allocate memory for mv buffer array */
ps_codec->ps_mv_buf = ps_codec->pv_mv_bank_buf_base;
pu1_buf = ps_codec->pv_mv_bank_buf_base;
pu1_buf += BUF_MGR_MAX_CNT * sizeof(mv_buf_t);
/********************************************************************/
/* allocate memory for individual elements of mv buffer ptr */
/********************************************************************/
mv_bank_size_allocated = ps_codec->i4_total_mv_bank_size
- (BUF_MGR_MAX_CNT * sizeof(mv_buf_t));
/* compute MV bank size per picture */
pic_mv_bank_size = ih264e_get_pic_mv_bank_size(num_luma_samples);
num_pu = num_luma_samples / (ENC_MIN_PU_SIZE * ENC_MIN_PU_SIZE);
num_mb = num_luma_samples / (MB_SIZE * MB_SIZE);
i = 0;
ps_mv_buf = ps_codec->pv_mv_bank_buf_base;
while (i < max_dpb_size)
{
mv_bank_size_allocated -= pic_mv_bank_size;
if (mv_bank_size_allocated < 0)
{
ps_codec->i4_error_code = IH264E_INSUFFICIENT_MEM_MVBANK;
error_status = IH264E_INSUFFICIENT_MEM_MVBANK;
return error_status;
}
ps_mv_buf->pu4_mb_pu_cnt = (UWORD32 *) pu1_buf;
pu1_buf += num_mb * sizeof(WORD32);
ps_mv_buf->pu1_pic_pu_map = pu1_buf;
pu1_buf += ALIGN4(num_pu);
ps_mv_buf->ps_pic_pu = (enc_pu_t *) (pu1_buf);
pu1_buf += ALIGN4(num_pu * sizeof(enc_pu_t));
ret = ih264_buf_mgr_add((buf_mgr_t *) ps_codec->pv_mv_buf_mgr,
ps_mv_buf, i);
if (IH264_SUCCESS != ret)
{
ps_codec->i4_error_code = IH264E_BUF_MGR_ERROR;
error_status = IH264E_BUF_MGR_ERROR;
return error_status;
}
ps_mv_buf++;
i++;
}
return error_status;
}
/**
*******************************************************************************
*
* @brief Function to initialize quant params structure
*
* @par Description:
* The forward quantization modules depends on qp/6, qp mod 6, forward scale
* matrix, forward threshold matrix, weight list. The inverse quantization
* modules depends on qp/6, qp mod 6, inverse scale matrix, weight list.
* These params are initialized in this function.
*
* @param[in] ps_proc
* pointer to process context
*
* @param[in] qp
* quantization parameter
*
* @returns none
*
* @remarks
*
*******************************************************************************
*/
void ih264e_init_quant_params(process_ctxt_t *ps_proc, int qp)
{
/* quant params */
quant_params_t *ps_qp_params;
/* ptr to forward quant threshold matrix */
const UWORD16 *pu2_thres_mat = NULL;
/* ptr to forward scale matrix */
const UWORD16 *pu2_scale_mat = gu2_quant_scale_matrix_4x4;
/* ptr to inverse scale matrix */
const UWORD16 *pu2_iscale_mat = gau2_ih264_iquant_scale_matrix_4x4;
/* temp var */
UWORD32 u4_qp[3], u4_qp_div6, u4_qp_mod6;
COMPONENT_TYPE plane;
WORD32 i;
UWORD32 u4_satdq_t;
const UWORD16 *pu2_smat;
/********************************************************************/
/* init quant params for all planes Y, U and V */
/********************************************************************/
/* luma qp */
u4_qp[Y] = qp;
/* chroma qp
* TODO_LATER : just in case if the chroma planes use different qp's this
* needs to be corrected accordingly.
*/
u4_qp[U] = gu1_qpc_fqpi[qp];
u4_qp[V] = gu1_qpc_fqpi[qp];
plane = Y;
while (plane <= V)
{
u4_qp_div6 = (u4_qp[plane] / 6);
u4_qp_mod6 = (u4_qp[plane] % 6);
ps_qp_params = ps_proc->ps_qp_params[plane];
/* mb qp */
ps_qp_params->u1_mb_qp = u4_qp[plane];
/* mb qp / 6 */
ps_qp_params->u1_qp_div = u4_qp_div6;
/* mb qp % 6 */
ps_qp_params->u1_qp_rem = u4_qp_mod6;
/* QP bits */
ps_qp_params->u1_qbits = QP_BITS_h264_4x4 + u4_qp_div6;
/* forward scale matrix */
ps_qp_params->pu2_scale_mat = pu2_scale_mat + (u4_qp_mod6 * 16);
/* threshold matrix & weight for quantization */
pu2_thres_mat = gu2_forward_quant_threshold_4x4 + (u4_qp_mod6 * 16);
for (i = 0; i < 16; i++)
{
ps_qp_params->pu2_thres_mat[i] = pu2_thres_mat[i]
>> (8 - u4_qp_div6);
ps_qp_params->pu2_weigh_mat[i] = 16;
}
/* qp dependent rounding constant */
ps_qp_params->u4_dead_zone =
gu4_forward_quant_round_factor_4x4[u4_qp_div6];
/* slice dependent rounding constant */
if (ps_proc->i4_slice_type != ISLICE
&& ps_proc->i4_slice_type != SISLICE)
{
ps_qp_params->u4_dead_zone >>= 1;
}
/* SATQD threshold for zero block prediction */
if (ps_proc->ps_codec->s_cfg.u4_enable_satqd)
{
pu2_smat = ps_qp_params->pu2_scale_mat;
u4_satdq_t = ((1 << (ps_qp_params->u1_qbits)) - ps_qp_params->u4_dead_zone);
ps_qp_params->pu2_sad_thrsh[0] = u4_satdq_t / MAX(pu2_smat[3], pu2_smat[11]);
ps_qp_params->pu2_sad_thrsh[1] = u4_satdq_t / MAX(pu2_smat[1], pu2_smat[9]);
ps_qp_params->pu2_sad_thrsh[2] = u4_satdq_t / pu2_smat[15];
ps_qp_params->pu2_sad_thrsh[3] = u4_satdq_t / pu2_smat[7];
ps_qp_params->pu2_sad_thrsh[4] = u4_satdq_t / MAX(pu2_smat[12], pu2_smat[14]);
ps_qp_params->pu2_sad_thrsh[5] = u4_satdq_t / MAX(pu2_smat[4], pu2_smat[6]);
ps_qp_params->pu2_sad_thrsh[6] = u4_satdq_t / pu2_smat[13];
ps_qp_params->pu2_sad_thrsh[7] = u4_satdq_t / pu2_smat[5];
ps_qp_params->pu2_sad_thrsh[8] = u4_satdq_t / MAX(MAX3(pu2_smat[0], pu2_smat[2], pu2_smat[8]), pu2_smat[10]);
}
/* inverse scale matrix */
ps_qp_params->pu2_iscale_mat = pu2_iscale_mat + (u4_qp_mod6 * 16);
plane += 1;
}
return ;
}
/**
*******************************************************************************
*
* @brief
* Initialize AIR mb frame Map
*
* @par Description:
* Initialize AIR mb frame map
* MB frame map indicates which frame an Mb should be coded as intra according to AIR
*
* @param[in] ps_codec
* Pointer to codec context
*
* @returns error_status
*
* @remarks
*
*
*******************************************************************************
*/
IH264E_ERROR_T ih264e_init_air_map(codec_t *ps_codec)
{
/* intra refresh map */
UWORD16 *pu2_intr_rfrsh_map = ps_codec->pu2_intr_rfrsh_map;
/* air mode */
IVE_AIR_MODE_T air_mode = ps_codec->s_cfg.e_air_mode;
/* refresh period */
UWORD32 air_period = ps_codec->s_cfg.u4_air_refresh_period;
/* mb cnt */
UWORD32 u4_mb_cnt = ps_codec->s_cfg.i4_wd_mbs * ps_codec->s_cfg.i4_ht_mbs;
/* temp var */
UWORD32 curr_mb, seed_rand = 1;
switch (air_mode)
{
case IVE_AIR_MODE_CYCLIC:
for (curr_mb = 0; curr_mb < u4_mb_cnt; curr_mb++)
{
pu2_intr_rfrsh_map[curr_mb] = curr_mb % air_period;
}
break;
case IVE_AIR_MODE_RANDOM:
for (curr_mb = 0; curr_mb < u4_mb_cnt; curr_mb++)
{
seed_rand = (seed_rand * 32719 + 3) % 32749;
pu2_intr_rfrsh_map[curr_mb] = seed_rand % air_period;
}
break;
default:
break;
}
return IH264E_SUCCESS;
}
/**
*******************************************************************************
*
* @brief
* Codec level initializations
*
* @par Description:
* Initializes the codec with parameters that needs to be set before encoding
* first frame
*
* @param[in] ps_codec
* Pointer to codec context
*
* @param[in] ps_inp_buf
* Pointer to input buffer context
*
* @returns error_status
*
* @remarks
*
*
*******************************************************************************
*/
IH264E_ERROR_T ih264e_codec_init(codec_t *ps_codec)
{
/********************************************************************
* INITIALIZE CODEC CONTEXT *
********************************************************************/
/* encoder presets */
if (ps_codec->s_cfg.u4_enc_speed_preset != IVE_CONFIG)
{
if (ps_codec->s_cfg.u4_enc_speed_preset == IVE_SLOWEST)
{/* high quality */
/* enable diamond search */
ps_codec->s_cfg.u4_me_speed_preset = DMND_SRCH;
ps_codec->s_cfg.u4_enable_fast_sad = 0;
/* disable intra 4x4 */
ps_codec->s_cfg.u4_enable_intra_4x4 = 1;
ps_codec->luma_energy_compaction[1] =
ih264e_code_luma_intra_macroblock_4x4_rdopt_on;
/* sub pel off */
ps_codec->s_cfg.u4_enable_hpel = 1;
/* deblocking off */
ps_codec->s_cfg.u4_disable_deblock_level = DISABLE_DEBLK_LEVEL_0;
/* disabled intra inter gating in Inter slices */
ps_codec->u4_inter_gate = 0;
}
else if (ps_codec->s_cfg.u4_enc_speed_preset == IVE_NORMAL)
{/* normal */
/* enable diamond search */
ps_codec->s_cfg.u4_me_speed_preset = DMND_SRCH;
ps_codec->s_cfg.u4_enable_fast_sad = 0;
/* disable intra 4x4 */
ps_codec->s_cfg.u4_enable_intra_4x4 = 1;
/* sub pel off */
ps_codec->s_cfg.u4_enable_hpel = 1;
/* deblocking off */
ps_codec->s_cfg.u4_disable_deblock_level = DISABLE_DEBLK_LEVEL_0;
/* disabled intra inter gating in Inter slices */
ps_codec->u4_inter_gate = 0;
}
else if (ps_codec->s_cfg.u4_enc_speed_preset == IVE_FAST)
{/* normal */
/* enable diamond search */
ps_codec->s_cfg.u4_me_speed_preset = DMND_SRCH;
ps_codec->s_cfg.u4_enable_fast_sad = 0;
/* disable intra 4x4 */
ps_codec->s_cfg.u4_enable_intra_4x4 = 0;
/* sub pel off */
ps_codec->s_cfg.u4_enable_hpel = 1;
/* deblocking off */
ps_codec->s_cfg.u4_disable_deblock_level = DISABLE_DEBLK_LEVEL_0;
/* disabled intra inter gating in Inter slices */
ps_codec->u4_inter_gate = 1;
}
else if (ps_codec->s_cfg.u4_enc_speed_preset == IVE_HIGH_SPEED)
{/* fast */
/* enable diamond search */
ps_codec->s_cfg.u4_me_speed_preset = DMND_SRCH;
ps_codec->s_cfg.u4_enable_fast_sad = 0;
/* disable intra 4x4 */
ps_codec->s_cfg.u4_enable_intra_4x4 = 0;
/* sub pel off */
ps_codec->s_cfg.u4_enable_hpel = 0;
/* deblocking off */
ps_codec->s_cfg.u4_disable_deblock_level = DISABLE_DEBLK_LEVEL_4;
/* disabled intra inter gating in Inter slices */
ps_codec->u4_inter_gate = 0;
}
else if (ps_codec->s_cfg.u4_enc_speed_preset == IVE_FASTEST)
{/* fastest */
/* enable diamond search */
ps_codec->s_cfg.u4_me_speed_preset = DMND_SRCH;
/* disable intra 4x4 */
ps_codec->s_cfg.u4_enable_intra_4x4 = 0;
/* sub pel off */
ps_codec->s_cfg.u4_enable_hpel = 0;
/* deblocking off */
ps_codec->s_cfg.u4_disable_deblock_level = DISABLE_DEBLK_LEVEL_4;
/* disabled intra inter gating in Inter slices */
ps_codec->u4_inter_gate = 1;
}
}
/*****************************************************************
* Initialize AIR inside codec
*****************************************************************/
if (IVE_AIR_MODE_NONE != ps_codec->s_cfg.e_air_mode)
{
ih264e_init_air_map(ps_codec);
ps_codec->i4_air_pic_cnt = -1;
}
/****************************************************/
/* INITIALIZE RATE CONTROL */
/****************************************************/
{
/* init qp */
UWORD8 au1_init_qp[MAX_PIC_TYPE];
/* min max qp */
UWORD8 au1_min_max_qp[2 * MAX_PIC_TYPE];
/* init i,p,b qp */
au1_init_qp[0] = gau1_h264_to_mpeg2_qmap[ps_codec->s_cfg.u4_i_qp];
au1_init_qp[1] = gau1_h264_to_mpeg2_qmap[ps_codec->s_cfg.u4_p_qp];
au1_init_qp[2] = gau1_h264_to_mpeg2_qmap[ps_codec->s_cfg.u4_b_qp];
/* init min max qp */
au1_min_max_qp[2 * I_PIC] =
gau1_h264_to_mpeg2_qmap[ps_codec->s_cfg.u4_i_qp_min];
au1_min_max_qp[2 * I_PIC + 1] =
gau1_h264_to_mpeg2_qmap[ps_codec->s_cfg.u4_i_qp_max];
au1_min_max_qp[2 * P_PIC] =
gau1_h264_to_mpeg2_qmap[ps_codec->s_cfg.u4_p_qp_min];
au1_min_max_qp[2 * P_PIC + 1] =
gau1_h264_to_mpeg2_qmap[ps_codec->s_cfg.u4_p_qp_max];
au1_min_max_qp[2 * B_PIC] =
gau1_h264_to_mpeg2_qmap[ps_codec->s_cfg.u4_b_qp_min];
au1_min_max_qp[2 * B_PIC + 1] =
gau1_h264_to_mpeg2_qmap[ps_codec->s_cfg.u4_b_qp_max];
/* get rc mode */
switch (ps_codec->s_cfg.e_rc_mode)
{
case IVE_RC_STORAGE:
ps_codec->s_rate_control.e_rc_type = VBR_STORAGE;
break;
case IVE_RC_CBR_NON_LOW_DELAY:
ps_codec->s_rate_control.e_rc_type = CBR_NLDRC;
break;
case IVE_RC_CBR_LOW_DELAY:
ps_codec->s_rate_control.e_rc_type = CBR_LDRC;
break;
case IVE_RC_NONE:
ps_codec->s_rate_control.e_rc_type = CONST_QP;
break;
default:
break;
}
/* init rate control */
ih264e_rc_init(ps_codec->s_rate_control.pps_rate_control_api,
ps_codec->s_rate_control.pps_frame_time,
ps_codec->s_rate_control.pps_time_stamp,
ps_codec->s_rate_control.pps_pd_frm_rate,
ps_codec->s_cfg.u4_max_framerate,
ps_codec->s_cfg.u4_src_frame_rate,
ps_codec->s_cfg.u4_tgt_frame_rate,
ps_codec->s_rate_control.e_rc_type,
ps_codec->s_cfg.u4_target_bitrate,
ps_codec->s_cfg.u4_max_bitrate,
ps_codec->s_cfg.u4_vbv_buffer_delay,
ps_codec->s_cfg.u4_i_frm_interval,
ps_codec->s_cfg.u4_num_bframes + 1, au1_init_qp,
ps_codec->s_cfg.u4_num_bframes + 2 , au1_min_max_qp,
MAX(ps_codec->s_cfg.u4_max_level,
(UWORD32)ih264e_get_min_level(ps_codec->s_cfg.u4_max_wd, ps_codec->s_cfg.u4_max_ht)));
}
/* recon stride */
ps_codec->i4_rec_strd = ALIGN16(ps_codec->s_cfg.u4_max_wd) + PAD_WD;
/* max ref and reorder cnt */
ps_codec->i4_ref_buf_cnt = ps_codec->s_cfg.u4_max_ref_cnt
+ ps_codec->s_cfg.u4_max_reorder_cnt;
ps_codec->i4_ref_buf_cnt += MAX_CTXT_SETS;
DEBUG_HISTOGRAM_INIT();
/* Init dependecy vars */
ps_codec->i4_last_inp_buff_received = 0;
/* At codec start no IDR is pending */
ps_codec->i4_pending_idr_flag = 0;
return IH264E_SUCCESS;
}
/**
*******************************************************************************
*
* @brief
* Picture level initializations
*
* @par Description:
* Before beginning to encode the frame, the current function initializes all
* the ctxts (proc, entropy, me, ...) basing on the input configured params.
* It locates space for storing recon in the encoder picture buffer set, fetches
* reference frame from encoder picture buffer set. Calls RC pre-enc to get
* qp and pic type for the current frame. Queues proc jobs so that
* the other threads can begin encoding. In brief, this function sets up the
* tone for the entire encoder.
*
* @param[in] ps_codec
* Pointer to codec context
*
* @param[in] ps_inp_buf
* Pointer to input buffer context
*
* @returns error_status
*
* @remarks
*
*
*******************************************************************************
*/
IH264E_ERROR_T ih264e_pic_init(codec_t *ps_codec, inp_buf_t *ps_inp_buf)
{
/* error status */
IH264E_ERROR_T error_status = IH264E_SUCCESS;
IH264_ERROR_T ret = IH264_SUCCESS;
/* mv buff bank */
mv_buf_t *ps_mv_buf = NULL;
WORD32 cur_mv_bank_buf_id;
/* recon buffer set */
pic_buf_t *ps_cur_pic;
WORD32 cur_pic_buf_id;
UWORD8 *pu1_cur_pic_luma, *pu1_cur_pic_chroma;
/* ref buffer set */
pic_buf_t *aps_ref_pic[MAX_REF_PIC_CNT] = {NULL, NULL};
mv_buf_t *aps_mv_buf[MAX_REF_PIC_CNT] = {NULL, NULL};
WORD32 ref_set_id;
/* pic time stamp */
UWORD32 u4_timestamp_high = ps_inp_buf->u4_timestamp_high;
UWORD32 u4_timestamp_low = ps_inp_buf->u4_timestamp_low;
/* indices to access curr/prev frame info */
WORD32 ctxt_sel = ps_codec->i4_encode_api_call_cnt % MAX_CTXT_SETS;
/* curr pic type */
PIC_TYPE_T *pic_type = &ps_codec->pic_type;
/* Diamond search Iteration Max Cnt */
UWORD32 u4_num_layers =
(ps_codec->s_cfg.u4_enc_speed_preset == IVE_FASTEST) ?
(NUM_LAYERS >> 2) : NUM_LAYERS;
/* enable fast sad */
UWORD32 u4_enable_fast_sad = ps_codec->s_cfg.u4_enable_fast_sad;
/********************************************************************/
/* INITIALIZE CODEC CONTEXT */
/********************************************************************/
/* slice_type */
if ((PIC_I == *pic_type) || (PIC_IDR == *pic_type))
{
ps_codec->i4_slice_type = ISLICE;
}
else if (PIC_P == *pic_type)
{
ps_codec->i4_slice_type = PSLICE;
}
else if(PIC_B == *pic_type)
{
ps_codec->i4_slice_type = BSLICE;
}
/***************************************************************************
* Set up variables for sending frame number, poc and reference
* a) Set up alt ref too
**************************************************************************/
/* Check and set if the current frame is reference or not */
ps_codec->u4_is_curr_frm_ref = 0;
/* This frame is reference if its not a B pic, pending approval from alt ref */
ps_codec->u4_is_curr_frm_ref = (*pic_type != PIC_B);
/* In case if its a P pic, we will decide according to alt ref also */
if (ps_codec->s_cfg.u4_enable_alt_ref && (*pic_type == PIC_P)
&& (ps_codec->i4_pic_cnt
% (ps_codec->s_cfg.u4_enable_alt_ref + 1)))
{
ps_codec->u4_is_curr_frm_ref = 0;
}
/*
* Override everything in case of IDR
* Note that in case of IDR, at this point ps_codec->u4_is_curr_frm_ref must
* be 1
*/
/* is this an IDR pic */
ps_codec->u4_is_idr = 0;
if (PIC_IDR == *pic_type)
{
/* set idr flag */
ps_codec->u4_is_idr = 1;
/* reset frame num */
ps_codec->i4_frame_num = 0;
/* idr_pic_id */
ps_codec->i4_idr_pic_id++;
}
/***************************************************************************
* Set up Deblock
**************************************************************************/
/* set deblock disable flags based on disable deblock level */
ps_codec->i4_disable_deblk_pic = 1;
if (ps_codec->s_cfg.u4_disable_deblock_level == DISABLE_DEBLK_LEVEL_0)
{
/* enable deblocking */
ps_codec->i4_disable_deblk_pic = 0;
}
else if (ps_codec->s_cfg.u4_disable_deblock_level == DISABLE_DEBLK_LEVEL_2)
{
/* enable deblocking after a period of frames */
if (ps_codec->i4_disable_deblk_pic_cnt == DISABLE_DEBLOCK_INTERVAL
|| ps_codec->i4_slice_type == ISLICE)
{
ps_codec->i4_disable_deblk_pic = 0;
}
}
else if (ps_codec->s_cfg.u4_disable_deblock_level == DISABLE_DEBLK_LEVEL_3)
{
if (ps_codec->i4_slice_type == ISLICE)
{
ps_codec->i4_disable_deblk_pic = 0;
}
}
if (ps_codec->i4_disable_deblk_pic)
{
ps_codec->i4_disable_deblk_pic_cnt++;
}
else
{
ps_codec->i4_disable_deblk_pic_cnt = 0;
}
/* In slice mode - lets not deblk mb edges that lie along slice boundaries */
if (ps_codec->i4_disable_deblk_pic == 0)
{
if (ps_codec->s_cfg.e_slice_mode != IVE_SLICE_MODE_NONE)
{
ps_codec->i4_disable_deblk_pic = 2;
}
}
/* error status */
ps_codec->i4_error_code = IH264E_SUCCESS;
/* populate header */
if (ps_codec->i4_gen_header)
{
/* sps */
sps_t *ps_sps = NULL;
/* pps */
pps_t *ps_pps = NULL;
/*ps_codec->i4_pps_id ++;*/
ps_codec->i4_pps_id %= MAX_PPS_CNT;
/*ps_codec->i4_sps_id ++;*/
ps_codec->i4_sps_id %= MAX_SPS_CNT;
/* populate sps header */
ps_sps = ps_codec->ps_sps_base + ps_codec->i4_sps_id;
ih264e_populate_sps(ps_codec, ps_sps);
/* populate pps header */
ps_pps = ps_codec->ps_pps_base + ps_codec->i4_pps_id;
ih264e_populate_pps(ps_codec, ps_pps);
}
/***************************************************************************
* Reference and MV bank Buffer Manager
* Here we will
* 1) Find the correct ref pics for the current frame
* 2) Free the ref pic that is not going to be used anywhere
* 3) Find a free buff from the list and assign it as the recon of
* current frame
*
* 1) Finding correct ref pic
* All pics needed for future are arranged in a picture list called
* ps_codec->as_ref_set. Each picture in this will have a pic buffer and
* MV buffer that is marked appropriately as BUF_MGR_REF, BUF_MGR_IO or
* BUF_MGR_CODEC. Also the pic_cnt and poc will also be present.
* Hence to find the ref pic we will loop through the list and find
* 2 pictures with maximum i4_pic_cnt .
*
* note that i4_pic_cnt == -1 is used to filter uninit ref pics.
* Now since we only have max two ref pics, we will always find max 2
* ref pics.
*
* 2) 3) Self explanatory
***************************************************************************/
{
/* Search for buffs with maximum pic cnt */
WORD32 max_pic_cnt[] = { -1, -1 };
mv_buf_t *ps_mv_buf_to_free[] = { NULL, NULL };
/* temp var */
WORD32 i, buf_status;
for (i = 0; i < ps_codec->i4_ref_buf_cnt; i++)
{
if (ps_codec->as_ref_set[i].i4_pic_cnt == -1)
continue;
buf_status = ih264_buf_mgr_get_status(
ps_codec->pv_ref_buf_mgr,
ps_codec->as_ref_set[i].ps_pic_buf->i4_buf_id);
/* Ideally we should look for buffer status of MV BUFF also. But since
* the correponding MV buffs also will be at the same state. It dosent
* matter as of now. But the check will make the logic better */
if ((max_pic_cnt[0] < ps_codec->as_ref_set[i].i4_pic_cnt)
&& (buf_status & BUF_MGR_REF))
{
if (max_pic_cnt[1] < ps_codec->as_ref_set[i].i4_pic_cnt)
{
max_pic_cnt[0] = max_pic_cnt[1];
aps_ref_pic[0] = aps_ref_pic[1];
aps_mv_buf[0] = aps_mv_buf[1];
ps_mv_buf_to_free[0] = ps_mv_buf_to_free[1];
max_pic_cnt[1] = ps_codec->as_ref_set[i].i4_pic_cnt;
aps_ref_pic[1] = ps_codec->as_ref_set[i].ps_pic_buf;
aps_mv_buf[1] = ps_codec->as_ref_set[i].ps_mv_buf;
ps_mv_buf_to_free[1] = ps_codec->as_ref_set[i].ps_mv_buf;
}
else
{
max_pic_cnt[0] = ps_codec->as_ref_set[i].i4_pic_cnt;
aps_ref_pic[0] = ps_codec->as_ref_set[i].ps_pic_buf;
aps_mv_buf[0] = ps_codec->as_ref_set[i].ps_mv_buf;
ps_mv_buf_to_free[0] = ps_codec->as_ref_set[i].ps_mv_buf;
}
}
}
/*
* Now if the current picture is I or P, we discard the back ref pic and
* assign forward ref as backward ref
*/
if (*pic_type != PIC_B)
{
if (ps_mv_buf_to_free[0])
{
/* release this frame from reference list */
ih264_buf_mgr_release(ps_codec->pv_mv_buf_mgr,
ps_mv_buf_to_free[0]->i4_buf_id,
BUF_MGR_REF);
ih264_buf_mgr_release(ps_codec->pv_ref_buf_mgr,
aps_ref_pic[0]->i4_buf_id, BUF_MGR_REF);
}
max_pic_cnt[0] = max_pic_cnt[1];
aps_ref_pic[0] = aps_ref_pic[1];
aps_mv_buf[0] = aps_mv_buf[1];
/* Dummy */
max_pic_cnt[1] = -1;
}
/*
* Mark all reference pic with unused buffers to be free
* We need this step since each one, ie ref, recon io etc only unset their
* respective flags. Hence we need to combine togather and mark the ref set
* accordingly
*/
ref_set_id = -1;
for (i = 0; i < ps_codec->i4_ref_buf_cnt; i++)
{
if (ps_codec->as_ref_set[i].i4_pic_cnt == -1)
{
ref_set_id = i;
continue;
}
buf_status = ih264_buf_mgr_get_status(
ps_codec->pv_ref_buf_mgr,
ps_codec->as_ref_set[i].ps_pic_buf->i4_buf_id);
if ((buf_status & (BUF_MGR_REF | BUF_MGR_CODEC | BUF_MGR_IO)) == 0)
{
ps_codec->as_ref_set[i].i4_pic_cnt = -1;
ps_codec->as_ref_set[i].i4_poc = 32768;
ref_set_id = i;
}
}
/* An asssert failure here means we donot have any free buffs */
ASSERT(ref_set_id >= 0);
}
{
/*****************************************************************/
/* Get free MV Bank to hold current picture's motion vector data */
/* If there are no free buffers then return with an error code. */
/* If the buffer is to be freed by another thread, change the */
/* following to call thread yield and wait for buffer to be freed*/
/*****************************************************************/
ps_mv_buf = (mv_buf_t *) ih264_buf_mgr_get_next_free(
(buf_mgr_t *) ps_codec->pv_mv_buf_mgr,
&cur_mv_bank_buf_id);
if (NULL == ps_mv_buf)
{
ps_codec->i4_error_code = IH264E_NO_FREE_MVBANK;
return IH264E_NO_FREE_MVBANK;
}
/* mark the buffer as needed for reference if the curr pic is available for ref */
if (ps_codec->u4_is_curr_frm_ref)
{
ih264_buf_mgr_set_status(ps_codec->pv_mv_buf_mgr,
cur_mv_bank_buf_id, BUF_MGR_REF);
}
/* Set current ABS poc to ps_mv_buf, so that while freeing a reference buffer
* corresponding mv buffer can be found by looping through ps_codec->ps_mv_buf array
* and getting a buffer id to free
*/
ps_mv_buf->i4_abs_poc = ps_codec->i4_abs_pic_order_cnt;
ps_mv_buf->i4_buf_id = cur_mv_bank_buf_id;
}
{
/*****************************************************************/
/* Get free pic buf to hold current picture's recon data */
/* If there are no free buffers then return with an error code. */
/* If the buffer is to be freed by another thread, change the */
/* following to call thread yield and wait for buffer to be freed*/
/*****************************************************************/
ps_cur_pic = (pic_buf_t *) ih264_buf_mgr_get_next_free(
(buf_mgr_t *) ps_codec->pv_ref_buf_mgr,
&cur_pic_buf_id);
if (NULL == ps_cur_pic)
{
ps_codec->i4_error_code = IH264E_NO_FREE_PICBUF;
return IH264E_NO_FREE_PICBUF;
}
/* mark the buffer as needed for reference if the curr pic is available for ref */
if (ps_codec->u4_is_curr_frm_ref)
{
ih264_buf_mgr_set_status(ps_codec->pv_ref_buf_mgr, cur_pic_buf_id,
BUF_MGR_REF);
}
/* Mark the current buffer as needed for IO if recon is enabled */
if (1 == ps_codec->s_cfg.u4_enable_recon)
{
ih264_buf_mgr_set_status(ps_codec->pv_ref_buf_mgr, cur_pic_buf_id,
BUF_MGR_IO);
}
/* Associate input timestamp with current buffer */
ps_cur_pic->u4_timestamp_high = ps_inp_buf->u4_timestamp_high;
ps_cur_pic->u4_timestamp_low = ps_inp_buf->u4_timestamp_low;
ps_cur_pic->i4_abs_poc = ps_codec->i4_poc;
ps_cur_pic->i4_poc_lsb = ps_codec->i4_pic_order_cnt_lsb;
ps_cur_pic->i4_buf_id = cur_pic_buf_id;
pu1_cur_pic_luma = ps_cur_pic->pu1_luma;
pu1_cur_pic_chroma = ps_cur_pic->pu1_chroma;
}
/*
* Add the current picture to ref list independent of the fact that it is used
* as reference or not. This is because, now recon is not in sync with output
* hence we may need the current recon after some delay. By adding it to ref list
* we can retrieve the recon any time we want. The information that it is used
* for ref can still be found by checking the buffer status of pic buf.
*/
{
ps_codec->as_ref_set[ref_set_id].i4_pic_cnt = ps_codec->i4_pic_cnt;
ps_codec->as_ref_set[ref_set_id].i4_poc = ps_codec->i4_poc;
ps_codec->as_ref_set[ref_set_id].ps_mv_buf = ps_mv_buf;
ps_codec->as_ref_set[ref_set_id].ps_pic_buf = ps_cur_pic;
}
/********************************************************************/
/* INITIALIZE PROCESS CONTEXT */
/********************************************************************/
{
/* temp var */
WORD32 i, j = 0;
/* curr proc ctxt */
process_ctxt_t *ps_proc = NULL;
j = ctxt_sel * MAX_PROCESS_THREADS;
/* begin init */
for (i = j; i < (j + MAX_PROCESS_THREADS); i++)
{
ps_proc = &ps_codec->as_process[i];
/* luma src buffer */
if (ps_codec->s_cfg.e_inp_color_fmt == IV_YUV_422ILE)
{
ps_proc->pu1_src_buf_luma_base = ps_codec->pu1_y_csc_buf_base;
}
else
{
ps_proc->pu1_src_buf_luma_base =
ps_inp_buf->s_raw_buf.apv_bufs[0];
}
/* chroma src buffer */
if (ps_codec->s_cfg.e_inp_color_fmt == IV_YUV_422ILE
|| ps_codec->s_cfg.e_inp_color_fmt == IV_YUV_420P)
{
ps_proc->pu1_src_buf_chroma_base =
ps_codec->pu1_uv_csc_buf_base;
}
else
{
ps_proc->pu1_src_buf_chroma_base =
ps_inp_buf->s_raw_buf.apv_bufs[1];
}
/* luma rec buffer */
ps_proc->pu1_rec_buf_luma_base = pu1_cur_pic_luma;
/* chroma rec buffer */
ps_proc->pu1_rec_buf_chroma_base = pu1_cur_pic_chroma;
/* rec stride */
ps_proc->i4_rec_strd = ps_codec->i4_rec_strd;
/* frame num */
ps_proc->i4_frame_num = ps_codec->i4_frame_num;
/* is idr */
ps_proc->u4_is_idr = ps_codec->u4_is_idr;
/* idr pic id */
ps_proc->u4_idr_pic_id = ps_codec->i4_idr_pic_id;
/* slice_type */
ps_proc->i4_slice_type = ps_codec->i4_slice_type;
/* Input width in mbs */
ps_proc->i4_wd_mbs = ps_codec->s_cfg.i4_wd_mbs;
/* Input height in mbs */
ps_proc->i4_ht_mbs = ps_codec->s_cfg.i4_ht_mbs;
/* Half x plane offset from pic buf */
ps_proc->u4_half_x_offset = 0;
/* Half y plane offset from half x plane */
ps_proc->u4_half_y_offset = 0;
/* Half x plane offset from half y plane */
ps_proc->u4_half_xy_offset = 0;
/* top row syntax elements */
ps_proc->ps_top_row_mb_syntax_ele =
ps_proc->ps_top_row_mb_syntax_ele_base;
ps_proc->pu1_top_mb_intra_modes =
ps_proc->pu1_top_mb_intra_modes_base;
ps_proc->ps_top_row_pu = ps_proc->ps_top_row_pu_base;
/* initialize quant params */
ps_proc->u4_frame_qp = ps_codec->u4_frame_qp;
ps_proc->u4_mb_qp = ps_codec->u4_frame_qp;
ih264e_init_quant_params(ps_proc, ps_proc->u4_frame_qp);
/* previous mb qp*/
ps_proc->u4_mb_qp_prev = ps_proc->u4_frame_qp;
/* Reset frame info */
memset(&ps_proc->s_frame_info, 0, sizeof(frame_info_t));
/* initialize proc, deblk and ME map */
if (i == j)
{
/* row '-1' */
memset(ps_proc->pu1_proc_map - ps_proc->i4_wd_mbs, 1, ps_proc->i4_wd_mbs);
/* row 0 to ht in mbs */
memset(ps_proc->pu1_proc_map, 0, ps_proc->i4_wd_mbs * ps_proc->i4_ht_mbs);
/* row '-1' */
memset(ps_proc->pu1_deblk_map - ps_proc->i4_wd_mbs, 1, ps_proc->i4_wd_mbs);
/* row 0 to ht in mbs */
memset(ps_proc->pu1_deblk_map, 0, ps_proc->i4_wd_mbs * ps_proc->i4_ht_mbs);
/* row '-1' */
memset(ps_proc->pu1_me_map - ps_proc->i4_wd_mbs, 1, ps_proc->i4_wd_mbs);
/* row 0 to ht in mbs */
memset(ps_proc->pu1_me_map, 0, ps_proc->i4_wd_mbs * ps_proc->i4_ht_mbs);
/* at the start of air refresh period, reset intra coded map */
if (IVE_AIR_MODE_NONE != ps_codec->s_cfg.e_air_mode)
{
ps_codec->i4_air_pic_cnt = (ps_codec->i4_air_pic_cnt + 1)
% ps_codec->s_cfg.u4_air_refresh_period;
if (!ps_codec->i4_air_pic_cnt)
{
memset(ps_proc->pu1_is_intra_coded, 0, ps_proc->i4_wd_mbs * ps_proc->i4_ht_mbs);
}
}
}
/* deblock level */
ps_proc->u4_disable_deblock_level = ps_codec->i4_disable_deblk_pic;
/* slice index map */
/* no slice */
if (ps_codec->s_cfg.e_slice_mode == IVE_SLICE_MODE_NONE)
{
memset(ps_proc->pu1_slice_idx, 0, ps_proc->i4_wd_mbs * ps_proc->i4_ht_mbs);
}
/* generate slices for every 'n' rows, 'n' is given through slice param */
else if (ps_codec->s_cfg.e_slice_mode == IVE_SLICE_MODE_BLOCKS)
{
/* slice idx map */
UWORD8 *pu1_slice_idx = ps_proc->pu1_slice_idx;
/* temp var */
WORD32 i4_mb_y = 0, slice_idx = 0, cnt;
while (i4_mb_y < ps_proc->i4_ht_mbs)
{
if (i4_mb_y +(WORD32)ps_codec->s_cfg.u4_slice_param < ps_proc->i4_ht_mbs)
{
cnt = ps_codec->s_cfg.u4_slice_param * ps_proc->i4_wd_mbs;
i4_mb_y += ps_codec->s_cfg.u4_slice_param;
}
else
{
cnt = (ps_proc->i4_ht_mbs - i4_mb_y) * ps_proc->i4_wd_mbs;
i4_mb_y += (ps_proc->i4_ht_mbs - i4_mb_y);
}
memset(pu1_slice_idx, slice_idx, cnt);
slice_idx++;
pu1_slice_idx += cnt;
}
}
/* Current MV Bank's buffer ID */
ps_proc->i4_cur_mv_bank_buf_id = cur_mv_bank_buf_id;
/* Pointer to current picture buffer structure */
ps_proc->ps_cur_pic = ps_cur_pic;
/* Pointer to current pictures mv buffers */
ps_proc->ps_cur_mv_buf = ps_mv_buf;
/*
* pointer to ref picture
* 0 : Temporal back reference
* 1 : Temporal forward reference
*/
ps_proc->aps_ref_pic[PRED_L0] = aps_ref_pic[PRED_L0];
ps_proc->aps_ref_pic[PRED_L1] = aps_ref_pic[PRED_L1];
if (ps_codec->pic_type == PIC_B)
{
ps_proc->aps_mv_buf[PRED_L0] = aps_mv_buf[PRED_L0];
ps_proc->aps_mv_buf[PRED_L1] = aps_mv_buf[PRED_L1];
}
else
{
/*
* Else is dummy since for non B pic we does not need this
* But an assignment here will help in not having a segfault
* when we calcualte colpic in P slices
*/
ps_proc->aps_mv_buf[PRED_L0] = ps_mv_buf;
ps_proc->aps_mv_buf[PRED_L1] = ps_mv_buf;
}
if ((*pic_type != PIC_IDR) && (*pic_type != PIC_I))
{
/* temporal back an forward ref pointer luma and chroma */
ps_proc->apu1_ref_buf_luma_base[PRED_L0] = aps_ref_pic[PRED_L0]->pu1_luma;
ps_proc->apu1_ref_buf_chroma_base[PRED_L0] = aps_ref_pic[PRED_L0]->pu1_chroma;
ps_proc->apu1_ref_buf_luma_base[PRED_L1] = aps_ref_pic[PRED_L1]->pu1_luma;
ps_proc->apu1_ref_buf_chroma_base[PRED_L1] = aps_ref_pic[PRED_L1]->pu1_chroma;
}
/* Structure for current input buffer */
ps_proc->s_inp_buf = *ps_inp_buf;
/* Number of encode frame API calls made */
ps_proc->i4_encode_api_call_cnt = ps_codec->i4_encode_api_call_cnt;
/* Current Picture count */
ps_proc->i4_pic_cnt = ps_codec->i4_pic_cnt;
/* error status */
ps_proc->i4_error_code = 0;
/********************************************************************/
/* INITIALIZE ENTROPY CONTEXT */
/********************************************************************/
{
entropy_ctxt_t *ps_entropy = &ps_proc->s_entropy;
/* start of frame */
ps_entropy->i4_sof = 0;
/* end of frame */
ps_entropy->i4_eof = 0;
/* generate header */
ps_entropy->i4_gen_header = ps_codec->i4_gen_header;
/* sps ref_set_id */
ps_entropy->u4_sps_id = ps_codec->i4_sps_id;
/* sps base */
ps_entropy->ps_sps_base = ps_codec->ps_sps_base;
/* sps id */
ps_entropy->u4_pps_id = ps_codec->i4_pps_id;
/* sps base */
ps_entropy->ps_pps_base = ps_codec->ps_pps_base;
/* slice map */
ps_entropy->pu1_slice_idx = ps_proc->pu1_slice_idx;
/* slice hdr base */
ps_entropy->ps_slice_hdr_base = ps_proc->ps_slice_hdr_base;
/* Abs poc */
ps_entropy->i4_abs_pic_order_cnt = ps_proc->ps_codec->i4_poc;
/* initialize entropy map */
if (i == j)
{
/* row '-1' */
memset(ps_entropy->pu1_entropy_map - ps_proc->i4_wd_mbs, 1, ps_proc->i4_wd_mbs);
/* row 0 to ht in mbs */
memset(ps_entropy->pu1_entropy_map, 0, ps_proc->i4_wd_mbs * ps_proc->i4_ht_mbs);
/* intialize cabac tables */
ih264e_init_cabac_table(ps_entropy);
}
/* wd in mbs */
ps_entropy->i4_wd_mbs = ps_proc->i4_wd_mbs;
/* ht in mbs */
ps_entropy->i4_ht_mbs = ps_proc->i4_ht_mbs;
/* transform_8x8_mode_flag */
ps_entropy->i1_transform_8x8_mode_flag = 0;
/* entropy_coding_mode_flag */
ps_entropy->u1_entropy_coding_mode_flag =
ps_codec->s_cfg.u4_entropy_coding_mode;
/* error code */
ps_entropy->i4_error_code = IH264E_SUCCESS;
/* mb skip run */
*(ps_proc->s_entropy.pi4_mb_skip_run) = 0;
/* last frame to encode */
ps_proc->s_entropy.u4_is_last = ps_inp_buf->u4_is_last;
/* Current Picture count */
ps_proc->s_entropy.i4_pic_cnt = ps_codec->i4_pic_cnt;
/* time stamps */
ps_entropy->u4_timestamp_low = u4_timestamp_low;
ps_entropy->u4_timestamp_high = u4_timestamp_high;
/* init frame statistics */
ps_entropy->u4_header_bits[MB_TYPE_INTRA] = 0;
ps_entropy->u4_header_bits[MB_TYPE_INTER] = 0;
ps_entropy->u4_residue_bits[MB_TYPE_INTRA] = 0;
ps_entropy->u4_residue_bits[MB_TYPE_INTER] = 0;
}
/********************************************************************/
/* INITIALIZE DEBLOCK CONTEXT */
/********************************************************************/
{
/* deblk ctxt */
deblk_ctxt_t *ps_deblk = &ps_proc->s_deblk_ctxt;
/* slice idx map */
ps_deblk->pu1_slice_idx = ps_proc->pu1_slice_idx;
}
/********************************************************************/
/* INITIALIZE ME CONTEXT */
/********************************************************************/
{
/* me ctxt */
me_ctxt_t *ps_me_ctxt = &ps_proc->s_me_ctxt;
/* srch range x */
ps_me_ctxt->ai2_srch_boundaries[0] =
ps_codec->s_cfg.u4_srch_rng_x;
/* srch range y */
ps_me_ctxt->ai2_srch_boundaries[1] =
ps_codec->s_cfg.u4_srch_rng_y;
/* rec stride */
ps_me_ctxt->i4_rec_strd = ps_codec->i4_rec_strd;
/* Half x plane offset from pic buf */
ps_me_ctxt->u4_half_x_offset = ps_proc->u4_half_x_offset;
/* Half y plane offset from half x plane */
ps_me_ctxt->u4_half_y_offset = ps_proc->u4_half_y_offset;
/* Half x plane offset from half y plane */
ps_me_ctxt->u4_half_xy_offset = ps_proc->u4_half_xy_offset;
/* enable fast sad */
ps_me_ctxt->u4_enable_fast_sad = u4_enable_fast_sad;
/* half pel */
ps_me_ctxt->u4_enable_hpel = ps_codec->s_cfg.u4_enable_hpel;
/* Diamond search Iteration Max Cnt */
ps_me_ctxt->u4_num_layers = u4_num_layers;
/* me speed preset */
ps_me_ctxt->u4_me_speed_preset =
ps_codec->s_cfg.u4_me_speed_preset;
/* qp */
ps_me_ctxt->u1_mb_qp = ps_codec->u4_frame_qp;
if ((i == j) && (0 == ps_codec->i4_poc))
{
/* init mv bits tables */
ih264e_init_mv_bits(ps_me_ctxt);
}
}
ps_proc->ps_ngbr_avbl = &(ps_proc->s_ngbr_avbl);
}
/* reset encoder header */
ps_codec->i4_gen_header = 0;
}
/********************************************************************/
/* ADD JOBS TO THE QUEUE */
/********************************************************************/
{
/* job structures */
job_t s_job;
/* temp var */
WORD32 i;
/* job class */
s_job.i4_cmd = CMD_PROCESS;
/* number of mbs to be processed in the current job */
s_job.i2_mb_cnt = ps_codec->s_cfg.i4_wd_mbs;
/* job start index x */
s_job.i2_mb_x = 0;
/* proc base idx */
s_job.i2_proc_base_idx = ctxt_sel ? (MAX_PROCESS_CTXT / 2) : 0;
for (i = 0; i < (WORD32)ps_codec->s_cfg.i4_ht_mbs; i++)
{
/* job start index y */
s_job.i2_mb_y = i;
/* queue the job */
ret = ih264_list_queue(ps_codec->pv_proc_jobq, &s_job, 1);
if (ret != IH264_SUCCESS)
{
ps_codec->i4_error_code = ret;
return IH264E_FAIL;
}
}
/* Once all the jobs are queued, terminate the queue */
/* Since the threads are created and deleted in each call, terminating
here is not an issue */
ih264_list_terminate(ps_codec->pv_proc_jobq);
}
return error_status;
}