| /* |
| * Copyright (c) 2016, 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. |
| */ |
| #ifndef AOM_AV1_ENCODER_PICKRST_H_ |
| #define AOM_AV1_ENCODER_PICKRST_H_ |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| #include "av1/encoder/encoder.h" |
| #include "aom_ports/system_state.h" |
| |
| struct yv12_buffer_config; |
| struct AV1_COMP; |
| |
| static const uint8_t g_shuffle_stats_data[16] = { |
| 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, |
| }; |
| |
| static const uint8_t g_shuffle_stats_highbd_data[32] = { |
| 0, 1, 2, 3, 2, 3, 4, 5, 4, 5, 6, 7, 6, 7, 8, 9, |
| 0, 1, 2, 3, 2, 3, 4, 5, 4, 5, 6, 7, 6, 7, 8, 9, |
| }; |
| |
| static INLINE uint8_t find_average(const uint8_t *src, int h_start, int h_end, |
| int v_start, int v_end, int stride) { |
| uint64_t sum = 0; |
| for (int i = v_start; i < v_end; i++) { |
| for (int j = h_start; j < h_end; j++) { |
| sum += src[i * stride + j]; |
| } |
| } |
| uint64_t avg = sum / ((v_end - v_start) * (h_end - h_start)); |
| return (uint8_t)avg; |
| } |
| |
| static INLINE uint16_t find_average_highbd(const uint16_t *src, int h_start, |
| int h_end, int v_start, int v_end, |
| int stride) { |
| uint64_t sum = 0; |
| for (int i = v_start; i < v_end; i++) { |
| for (int j = h_start; j < h_end; j++) { |
| sum += src[i * stride + j]; |
| } |
| } |
| uint64_t avg = sum / ((v_end - v_start) * (h_end - h_start)); |
| return (uint16_t)avg; |
| } |
| |
| void av1_pick_filter_restoration(const YV12_BUFFER_CONFIG *sd, |
| #if CONFIG_LOOP_RESTORE_CNN |
| bool allow_restore_cnn_y, |
| bool allow_restore_cnn_uv, |
| #endif // CONFIG_LOOP_RESTORE_CNN |
| AV1_COMP *cpi); |
| |
| // Function type to determine edge cost |
| // info : pointer to unspecified structure type, cast in function, holds any |
| // information needed to calculate edge cost |
| // path : pointer to Vector holding current path to edge represented as int |
| // indexes of nodes |
| // node_idx : node where path ends and edge starts |
| // max_out_nodes: max outgoing edges from node |
| // out_edge: outgoing edge we are calculating cost for |
| // Returns cost of edge. |
| typedef double (*graph_edge_cost_t)(const void *info, Vector *path, |
| int node_idx, int max_out_nodes, |
| int out_edge); |
| |
| // Exposed for testing purposes. |
| // src_idx : start of path |
| // dest_idx : destination of path |
| // best_path : pointer to Vector storing best path from start to destination |
| // as int indexes of nodes |
| // cost_fn : function to dynamically determine edge cost |
| // info : pointer to unspecified structure type cast in function, holds any |
| // information needed to calculate edge cost |
| // Returns cost of min-cost path. |
| |
| // Searching a directed graph for min cost path between node_idx and dest_idx. |
| // max_out_nodes: number of nodes in graph |
| // graph: n*n matrix where n is the number of nodes and element |
| // graph[n1 * n + n2] is an edge from n1 to n2 |
| double min_cost_path(int src_idx, int dest_idx, int max_out_nodes, |
| const double *graph, Vector *best_path, |
| graph_edge_cost_t cost_fn, const void *info); |
| |
| // Nodes are organized into subsets of equal size - each subset will have |
| // one node of every type. |
| // | /A/ | | /A/ | | /A/ | | /A/ | |
| // src | /B/ | | /B/ | | /B/ | | /B/ | dst |
| // | /C/ | | /C/ | | /C/ | | /C/ | |
| // 1 2 3 4 |
| // Every node has outgoing edges to every node in the next subset, i.e. |
| // 1A, 1B, and 1C will all have outgoing edges to 2A, 2B, and 2C. We are |
| // finding the type in each subset that will give us a min cost path from |
| // src to dest. |
| // max_out_nodes: number of nodes in a subset |
| // graph: a ((# of subsets * max_out_nodes + 2 nodes for src and dest) * |
| // max_out_nodes) matrix where element graph[n * max_out_nodes + e] is an edge |
| // from n to the eth node in the next subset. Last subset will only have one |
| // outgoing edge from each node to dst, dst has no outgoing edges. |
| // A B-Z |
| // [ x x x // src |
| // x x x // subset 1, type A |
| // x x x // subset 1, type B |
| // ... |
| // x x x // subset 2, type A |
| // x x x // subset 2, type B |
| // ... |
| // x I I // subset x, type A |
| // x I I // subset x, type B |
| // ... |
| // x I I // subset x, type Z |
| // I I I] // dst |
| double min_cost_type_path(int src_idx, int dest_idx, int max_out_nodes, |
| const double *graph, Vector *best_path, |
| graph_edge_cost_t cost_fn, const void *info); |
| |
| #ifdef __cplusplus |
| } // extern "C" |
| #endif |
| |
| #endif // AOM_AV1_ENCODER_PICKRST_H_ |