/*

 * Copyright (c) 2019, Alliance for Open Media. All rights reserved

 *

 * This source code is subject to the terms of the BSD 2 Clause License and

 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License

 * was not distributed with this source code in the LICENSE file, you can

 * obtain it at www.aomedia.org/license/software. If the Alliance for Open

 * Media Patent License 1.0 was not distributed with this source code in the

 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.

 */

/*!\file

 * \brief Declares frame encoding functions.

 */

#ifndef AOM_AV1_ENCODER_ENCODE_STRATEGY_H_

#define AOM_AV1_ENCODER_ENCODE_STRATEGY_H_

#ifdef __cplusplus

extern "C" {

#endif

#include <stdint.h>

#include "aom/aom_encoder.h"

#include "av1/encoder/encoder.h"

#include "av1/encoder/firstpass.h"

/*!\brief Implement high-level encode strategy

 *

 * \ingroup high_level_algo

 * \callgraph

 * \callergraph

 * This function will implement high-level encode strategy, choosing frame type,

 * frame placement, etc. It populates an EncodeFrameParams struct with the

 * results of these decisions and then encodes the frame. The caller should use

 * the output parameters *time_stamp and *time_end only when this function

 * returns AOM_CODEC_OK.

 *

 * \param[in]    cpi         Top-level encoder structure

 * \param[in]    size        Bitstream size

 * \param[in]    dest        Bitstream output

 * \param[in]    frame_flags Flags to decide how to encoding the frame

 * \param[out]   time_stamp  Time stamp of the frame

 * \param[out]   time_end    Time end

 * \param[in]    timestamp_ratio Time base

 * \param[in]    pop_lookahead Decide to pop the source frame from queue

 * \param[in]    flush       Decide to encode one frame or the rest of frames

 *

 * \return Returns a value to indicate if the encoding is done successfully.

 * \retval #AOM_CODEC_OK

 * \retval -1

 * \retval #AOM_CODEC_ERROR

 */

int av1_encode_strategy(AV1_COMP *const cpi, size_t *const size,

                        uint8_t *const dest, unsigned int *frame_flags,

                        int64_t *const time_stamp, int64_t *const time_end,

                        const aom_rational64_t *const timestamp_ratio,

                        int *const pop_lookahead, int flush);

/*!\cond */

// Set individual buffer update flags based on frame reference type.

// force_refresh_all is used when we have a KEY_FRAME or S_FRAME.  It forces all

// refresh_*_frame flags to be set, because we refresh all buffers in this case.

void av1_configure_buffer_updates(AV1_COMP *const cpi,

                                  RefreshFrameInfo *const refresh_frame,

                                  const FRAME_UPDATE_TYPE type,

                                  const REFBUF_STATE refbuf_state,

                                  int force_refresh_all);

int av1_get_refresh_frame_flags(const AV1_COMP *const cpi,

                                const EncodeFrameParams *const frame_params,

                                FRAME_UPDATE_TYPE frame_update_type,

                                int gf_index,

#if CONFIG_FRAME_PARALLEL_ENCODE

                                int cur_disp_order,

                                RefFrameMapPair ref_frame_map_pairs[REF_FRAMES],

#endif  // CONFIG_FRAME_PARALLEL_ENCODE

                                const RefBufferStack *const ref_buffer_stack);

int av1_get_refresh_ref_frame_map(int refresh_frame_flags);

void av1_update_ref_frame_map(const AV1_COMP *cpi,

                              FRAME_UPDATE_TYPE frame_update_type,

                              REFBUF_STATE refbuf_state, int ref_map_index,

                              RefBufferStack *ref_buffer_stack);

/*!\brief Obtain indices of reference frames from reference frame buffer stacks

 *

 * \callgraph

 * \callergraph

 *

 * \param[in]    ref_buffer_stack  Data structure for reference frame buffer

 *                                 stacks.

 * \param[out]   remapped_ref_idx  An array for storing indices of reference

 *                                 frames. The index is used to retrieve a

 *                                 reference frame buffer from ref_frame_map

 *                                 in AV1Common.

 */

void av1_get_ref_frames(const RefBufferStack *ref_buffer_stack,

#if CONFIG_FRAME_PARALLEL_ENCODE

                        RefFrameMapPair ref_frame_map_pairs[REF_FRAMES],

                        int cur_frame_disp,

#if CONFIG_FRAME_PARALLEL_ENCODE_2

                        const AV1_COMP *cpi, int gf_index,

                        int is_parallel_encode,

#endif  // CONFIG_FRAME_PARALLEL_ENCODE_2

#endif  // CONFIG_FRAME_PARALLEL_ENCODE

                        int remapped_ref_idx[REF_FRAMES]);

int is_forced_keyframe_pending(struct lookahead_ctx *lookahead,

                               const int up_to_index,

                               const COMPRESSOR_STAGE compressor_stage);

static AOM_INLINE int is_frame_droppable(

    const SVC *const svc,

    const ExtRefreshFrameFlagsInfo *const ext_refresh_frame_flags) {

  // Droppable frame is only used by external refresh flags. VoD setting won't

  // trigger its use case.

  if (svc->set_ref_frame_config)

    return svc->non_reference_frame;

  else if (ext_refresh_frame_flags->update_pending)

    return !(ext_refresh_frame_flags->alt_ref_frame ||

             ext_refresh_frame_flags->alt2_ref_frame ||

             ext_refresh_frame_flags->bwd_ref_frame ||

             ext_refresh_frame_flags->golden_frame ||

             ext_refresh_frame_flags->last_frame);

  else

    return 0;

}

Unexecuted instantiation: encoder.c:is_frame_droppable

Unexecuted instantiation: firstpass.c:is_frame_droppable

Unexecuted instantiation: pass2_strategy.c:is_frame_droppable

Unexecuted instantiation: ratectrl.c:is_frame_droppable

Unexecuted instantiation: tpl_model.c:is_frame_droppable

Unexecuted instantiation: encode_strategy.c:is_frame_droppable

static AOM_INLINE int get_current_frame_ref_type(const AV1_COMP *const cpi) {

  // We choose the reference "type" of this frame from the flags which indicate

  // which reference frames will be refreshed by it. More than one of these

  // flags may be set, so the order here implies an order of precedence. This is

  // just used to choose the primary_ref_frame (as the most recent reference

  // buffer of the same reference-type as the current frame).

  switch (cpi->ppi->gf_group.layer_depth[cpi->gf_frame_index]) {

    case 0: return 0;

    case 1: return 1;

    case MAX_ARF_LAYERS:

    case MAX_ARF_LAYERS + 1: return 4;

    default: return 7;

  }

}

Unexecuted instantiation: encoder.c:get_current_frame_ref_type

Unexecuted instantiation: firstpass.c:get_current_frame_ref_type

Unexecuted instantiation: pass2_strategy.c:get_current_frame_ref_type

Unexecuted instantiation: ratectrl.c:get_current_frame_ref_type

Unexecuted instantiation: tpl_model.c:get_current_frame_ref_type

Unexecuted instantiation: encode_strategy.c:get_current_frame_ref_type

#if CONFIG_FRAME_PARALLEL_ENCODE

#if CONFIG_FRAME_PARALLEL_ENCODE_2

int av1_calc_refresh_idx_for_intnl_arf(

    AV1_COMP *cpi, RefFrameMapPair ref_frame_map_pairs[REF_FRAMES],

    int gf_index);

#endif  // CONFIG_FRAME_PARALLEL_ENCODE_2

#endif  // CONFIG_FRAME_PARALLEL_ENCODE

/*!\endcond */

#ifdef __cplusplus

}  // extern "C"

#endif

#endif  // AOM_AV1_ENCODER_ENCODE_STRATEGY_H_