fw/parser/viddec_pm_tags.c

#include "viddec_pm.h"
#include "viddec_fw_debug.h"
#include "viddec_fw_common_defs.h"
#include "viddec_pm_tags.h"
/*
  Overview of tag association:

  Contribution flags:
  The current list has all the buffers which contribute to this particular workload. So we walkthrough the
  list and throw buf done for all the buffers which were consumed. This can be deduced from total bytes we
  in list which represents the bytes that were used for this acces unit.
  For buffers which were partially used and this can only be the last buffer we throw continued tag. The
  Parser manager tells us when to throw a continued tag. This will only happen when parser Manager detects
  that we reached end of current frame.

  Association Tags:
  These are the tags that FW generates which indicates how to associate metadata with Frames.
  The policy to determine which tag belongs to which frame is based on sc prefix position. If ES buffer starts with
  or has a sc prefix its associated to next decodable frame(based on first slice or header depending on codec).
  We use three state variables to determine where the frame starts and ends.
    frame_start_found: Indicates we saw the beggining of frame in current list of ES buffers(which represent current acces unit).
                       This is decremented on workload done since it normally means we detected frame end.
    found_fm_st_in_current_au:Indicates we saw the first slice in current access unit. Its mainly used to decide whether the first buffer
                              belongs to current frame or next frame. Its reset after its use.
    Frame Done: Indicates we detected end of frame pointed by current workload.

   Basic algo:
   If we find frame start and if first buffer doesn't start with SC prefix Every consumed buffer belongs to Next frame. If first buffer
   starts with SC prefix on that buffer belongs to Current frame.
   If we haven't found frame start every buffer belongs to current frame.

   TODO: Check for return codes from emitter
*/


/*
  This function generates contribution tags current workload by walking through list of consumed buffers.
  If frame is done(ignore_partial is false) we generate continue tags for the last item in list(if its not completely consumed).
  This is used for all codecs except H264.
 */
uint32_t viddec_pm_generic_generate_contribution_tags(void *parent, uint32_t ignore_partial)
{
    uint32_t ret = PM_SUCCESS;
    viddec_pm_cxt_t *cxt = (viddec_pm_cxt_t *)parent;
    viddec_pm_utils_list_t *list = &(cxt->list);

    if(list->num_items != 0)
    {
        if(!cxt->late_frame_detect)
        {
            uint32_t num_items = 0;
            while((num_items < list->num_items) && (list->data[num_items].edpos <= (uint32_t)list->total_bytes))
            {/* Walkthrough Consumed buffers and dump the tags */
                viddec_emit_contr_tag(&(cxt->emitter), &(list->sc_ibuf[num_items]), false, false);
                num_items++;
            }
            /* Dump incomplete tags if required */
            if(!ignore_partial)
            {/* check to see if last item is not consumed and dump continued flag */
                if((num_items < list->num_items)
                   && (list->data[num_items].edpos >= (uint32_t)list->total_bytes))
                {
                    viddec_emit_contr_tag(&(cxt->emitter), &(list->sc_ibuf[num_items]), true, false);
                }
            }
        }
        else
        {
            /* Only happens for dangling fields in MP2 Field pictures, in which case we find out the current frame was done in
               last access unit, which is similar to H264 */
            ret = viddec_pm_lateframe_generate_contribution_tags(parent, ignore_partial);
            cxt->late_frame_detect = false;
        }
    }
    return ret;
}

/*
  For H264 when a frame is done it really means current frame was done in last access unit. The current access unit represnted
  by list belongs to next frame. ignore_partial is false for frame done.
  When frame is not done we dump all consumed buffers into next workload else they go to current workload.
  If frame is done we throw a continued flag for first buffer in current workload if it was used in last access unit.
 */
uint32_t viddec_pm_lateframe_generate_contribution_tags(void *parent, uint32_t ignore_partial)
{
    uint32_t ret = PM_SUCCESS;
    viddec_pm_cxt_t *cxt = (viddec_pm_cxt_t *)parent;
    viddec_pm_utils_list_t *list = &(cxt->list);

    if(list->num_items != 0)
    {
        uint32_t num_items = 0;
        /* If start offset is not 0 then it was partially used in last access unit. !ignore_partial means frame done*/
        if((list->start_offset!= 0) && !ignore_partial)
        {/* Emit continue in current if necessary. */
            viddec_emit_contr_tag(&(cxt->emitter), &(list->sc_ibuf[num_items]), true, false);
        }

        while((num_items < list->num_items) && (list->data[num_items].edpos <= (uint32_t)list->total_bytes))
        {  /* Walkthrough Consumed buffers and dump the tags to current or Next*/
            viddec_emit_contr_tag(&(cxt->emitter), &(list->sc_ibuf[num_items]), false, !ignore_partial);
            num_items++;
        }
    }
    return ret;
}

/*
  This function dumps tags from temporary array into a workload(we indicate either current or next from using_next).
*/
uint32_t viddec_pm_generate_missed_association_tags(viddec_pm_cxt_t *cxt, uint32_t using_next)
{
    uint32_t i=0, ret = PM_SUCCESS;

    while((i < MAX_IBUFS_PER_SC) && (cxt->pending_tags.pending_tags[i] != INVALID_ENTRY))
    {
        viddec_emit_assoc_tag(&(cxt->emitter), cxt->pending_tags.pending_tags[i], using_next);
        cxt->pending_tags.pending_tags[i] = INVALID_ENTRY;
        i++;
    }
    return ret;
}

/* This function adds current list of es buffer to pending list. ignore_first when set tells us to ignore the first
   buffer in list.
*/
void viddec_pm_add_tags_to_pendinglist(viddec_pm_cxt_t *cxt, uint32_t ignore_first)
{
    viddec_pm_utils_list_t *list = &(cxt->list);
    vidded_pm_pending_tags_t *pend = &(cxt->pending_tags);
    uint32_t index=0, t_index=0;

    if(!ignore_first && (list->start_offset == 0))
    {/* If start offset is 0 we are saying that first buffer in list starts with start code */
        pend->first_buf_aligned = true;
    }
    else
    {/* We are ignoring first item in list since we already threw a tag for this buffer */
        index++;
        pend->first_buf_aligned  = false;
    }

    while( (index < list->num_items) && (list->data[index].edpos <= (uint32_t)list->total_bytes))
    {/* walk through consumed buffers and buffer id's in pending list */
        pend->pending_tags[t_index] = list->sc_ibuf[index].id;
        index++;t_index++;
    }
    if( (index < list->num_items) && (list->data[index].stpos < (uint32_t)list->total_bytes))
    {/* If last item is partially consumed still add it to pending tags since tag association is based on start of ES buffer */
        pend->pending_tags[t_index] = list->sc_ibuf[index].id;
    }
}

/* Helper function to emit a association tag from pending list and resetting the value to invalid entry */
static inline void viddec_pm_emit_pending_tag_item(viddec_emitter *emit, vidded_pm_pending_tags_t *pend, uint32_t index, uint32_t using_next)
{
    viddec_emit_assoc_tag(emit, pend->pending_tags[index], using_next);
    pend->pending_tags[index] = INVALID_ENTRY;
}

/*
  Tag association for mpeg2:
  start frame is detected in pict header extension, but pict header represents start of frame.
  To handle this we always store current AU list in temporary pending list. At the start of function
  we look to see if a frame start was found, if we did we start dumping items from pending list based
  on byte position of sc in first buffer of pending list. At the end we copy current list items to
  pending list.
  Limitation With Dangling fields: If we have AF1 AF2 BF1 CF1 CF2 as the sequence of fields
  Tag assocaiation will be fine for A & B, However the first buffer tag on C will fall into B
  We donot want to fix this issue right now as it means doubling size of pending list which
  increases memory usage. Normally dangling fields are thrown away so worst case we will miss
  one original PTS, So its OK not to fix it right now.
 */
uint32_t viddec_mpeg2_add_association_tags(void *parent)
{
    uint32_t ret = PM_SUCCESS;
    viddec_pm_cxt_t *cxt = (viddec_pm_cxt_t *)parent;
    vidded_pm_pending_tags_t *pend = &(cxt->pending_tags);
    uint32_t first_slice = false, index = 0;
    /* check to see if we found a frame start in current access unit */
    first_slice = cxt->frame_start_found && cxt->found_fm_st_in_current_au;
    cxt->found_fm_st_in_current_au = false;
    /* If we found frame start and first item in pending tags is start with start code
       then it needs to go to current frame. */
    if(first_slice && pend->first_buf_aligned && (pend->pending_tags[index] != INVALID_ENTRY))
    {
        viddec_pm_emit_pending_tag_item(&(cxt->emitter), pend, index, false);
        index++;
    }
    /* rest of list goes to current if frame start is not found else next frame */
    while((index < MAX_IBUFS_PER_SC) && (pend->pending_tags[index] != INVALID_ENTRY))
    {
        viddec_pm_emit_pending_tag_item(&(cxt->emitter), pend, index, cxt->frame_start_found);
        index++;
    }
    /* Copy items to temporary List */
    viddec_pm_add_tags_to_pendinglist(cxt, false);
    return ret;
}

/*
  Tag association for h264:
  In this case when we get frame done it means current frame was done in last access unit. The data in current list belongs
  to next frame. To handle this we always dump the buffered tags from last list and throw them in current/next frame based on pend state.
  If the first item in current list is on sc boundary, it has to go into next so we always throw that tag in next.
  For rest of items we store them in pending tags array and store inforamtion on where these stored tags should go into for
  next run. Thi is detemined by start frame. we do this because at this state our next should be current and "next next" should
  be next.
 */
uint32_t viddec_h264_add_association_tags(void *parent)
{
    uint32_t ret = PM_SUCCESS;
    viddec_pm_cxt_t *cxt = (viddec_pm_cxt_t *)parent;
    viddec_pm_utils_list_t *list = &(cxt->list);
    vidded_pm_pending_tags_t *pend = &(cxt->pending_tags);
    uint32_t first_slice = false, index = 0;

    /* Throw tags for items from pending list based on stored state  from last run */
    viddec_pm_generate_missed_association_tags(cxt, pend->using_next);
    first_slice = cxt->frame_start_found && cxt->found_fm_st_in_current_au;
    cxt->found_fm_st_in_current_au = false;
    /* If we saw frame start and first buffer is aligned to start code throw it into next */
    if(first_slice && (list->start_offset == 0))
    {
        viddec_emit_assoc_tag(&(cxt->emitter), list->sc_ibuf[index].id, cxt->frame_start_found && cxt->pending_tags.frame_done);
        index++;
    }
    /* add tags to pending list */
    viddec_pm_add_tags_to_pendinglist(cxt, (index != 0));
    /* We want to figure out where these buffers should go into. There are three possible cases
       current: If no frame start found these should go into next.
       next: If one frame start is found and frame is not done then it should go to next.
             if a frame is done then pm will push current out and next time we come here previous next is current.
       next next: If two frame starts are found then we want it to be next next workload, which is what next will be
                  when we get called next time.
    */
    pend->using_next = (!cxt->pending_tags.frame_done && (cxt->frame_start_found == 1)) || (cxt->frame_start_found > 1);
    return ret;
}

/*
  Tag association for vc1:
  Frame header represents start of new frame. If we saw a frame start in current access unit and the buffer starts
  with start code it needs to go to current frame.  Rest of items go to next if frame start found else current frame.
 */
uint32_t viddec_generic_add_association_tags(void *parent)
{
    uint32_t ret = PM_SUCCESS;
    viddec_pm_cxt_t *cxt = (viddec_pm_cxt_t *)parent;
    viddec_pm_utils_list_t *list = &(cxt->list);
    uint32_t not_first_slice = false, index = 0;

    /* We check to see if this access unit is not the first one with frame start. This evaluates to true in that case */
    not_first_slice = cxt->frame_start_found && !cxt->found_fm_st_in_current_au;
    cxt->found_fm_st_in_current_au = false;
    if(list->start_offset == 0)
    {/* If start offset is 0, we have start code at beggining of buffer. If frame start was detected in this
        access unit we put the tag in current else it goes to next */
        viddec_emit_assoc_tag(&(cxt->emitter), list->sc_ibuf[index].id, not_first_slice);
    }
    /* Skip first item always, for start_offset=0 its already been handled above*/
    index++;
    while( (index < list->num_items) && (list->data[index].edpos <= (uint32_t)list->total_bytes))
    {/* Walkthrough Consumed buffers and dump the tags to current or next*/
        viddec_emit_assoc_tag(&(cxt->emitter), list->sc_ibuf[index].id, cxt->frame_start_found);
        index++;
    }
    if( (index < list->num_items) && (list->data[index].stpos < (uint32_t)list->total_bytes))
    {/* Dump last item if it was partially consumed */
        viddec_emit_assoc_tag(&(cxt->emitter), list->sc_ibuf[index].id, cxt->frame_start_found);
    }
    return ret;
}

/*
  This function throws tags for buffers which were not used yet during flush.
 */
void viddec_pm_generate_tags_for_unused_buffers_to_flush(viddec_pm_cxt_t *cxt)
{
    viddec_pm_utils_list_t *list;
    uint32_t index=0;

    list = &(cxt->list);
    /* Generate association tags from temporary pending array */
    viddec_pm_generate_missed_association_tags(cxt, false);
    if(list->num_items > 0)
    {
        /* Throw contribution flag for first item as done */
        viddec_emit_contr_tag(&(cxt->emitter), &(list->sc_ibuf[index]), false, false);
        if(cxt->list.start_offset == 0)
        {/* Throw association for first item if it was not done already */
            viddec_emit_assoc_tag(&(cxt->emitter), list->sc_ibuf[index].id, false);
        }
        index++;
        while(index < list->num_items)
        {/* Walk through list and throw contribution and association flags */
            viddec_emit_contr_tag(&(cxt->emitter), &(list->sc_ibuf[index]), false, false);
            viddec_emit_assoc_tag(&(cxt->emitter), list->sc_ibuf[index].id, false);
            index++;
        }
    }
    /* Not required to re init list structure as flush takes care of it */
}