Давай добьем время
2025-06-22 13:28:57.020000954: 0 decode time: 0.020005 s
2025-06-22 13:28:57.040007566: 1 decode time: 0.020005 s
2025-06-22 13:28:57.060013531: 2 decode time: 0.020004 s
2025-06-22 13:28:57.080018417: 3 decode time: 0.020003 s
2025-06-22 13:28:57.100023140: 4 decode time: 0.020003 s


считается посмотри на секунды - не верно - задержка между каждой ровно 1 секунда
вот код
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>
#include <math.h>
#include <stdint.h>
#include <inttypes.h>
#include <unistd.h>
#include <semaphore.h>
#include <pthread.h>

#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/pixdesc.h>
#include <libswscale/swscale.h>
#include <libavutil/imgutils.h>

#include "rknn_api.h"  // Заголовочный файл RKNN SDK

#define LABEL_NALE_TXT_PATH "./coco_80_labels_list.txt"

// person car dog длинна строки
#define OBJ_NAME_MAX_SIZE 64
//Максимальное количество объектов (детектированных результатов)
#define OBJ_NUMB_MAX_SIZE 30
#define PROP_BOX_SIZE 80 // Обычно 5 + 80 классов

//Значение 0.45 означает, что боксы с перекрытием более 45% считаются дублирующими
#define NMS_THRESH        0.01

//начение 0.25 означает, что детекции с вероятностью (confidence) менее 25% будут отброшены.
#define BOX_THRESH        0.20

#define MODEL_PATH "./model.rknn"  	// Путь к RKNN модели
#define RKNN_WIDTH 640
#define RKNN_HEIGHT 640
// Кол-во классов модели
#define OBJ_CLASS_NUM 3
// Макс выходов, выставьте по факту у моделей обычно 3
#define MAX_OUTPUT_NUM 3


// Счётчик циклов ARM Cortex-A
static inline uint64_t read_cycle_counter() {
    uint32_t cycle_low, cycle_high;
    asm volatile("mrrc p15, 1, %0, %1, c14" : "=r"(cycle_low), "=r"(cycle_high));
    return ((uint64_t)cycle_high << 32) | cycle_low;
}

// Конвертация циклов в наносекунды (исходя из частоты 1.2 ГГц)
uint64_t cycles_to_ns(uint64_t cycles) {
	// cycles * 1_000_000_000 / 1_200_000_000 
    return (cycles * 1000000000ULL) / 1200000000ULL;
}

// Для GLOBAL_TIME — базовый отсчёт циклов (инициализируется при первом вызове)
static uint64_t base_cycles = 0;
static time_t base_unix_time = 0;

uint64_t start_ns() {
    if (base_cycles == 0) {
        base_cycles = read_cycle_counter();
        base_unix_time = time(NULL);
    }
    uint64_t delta_cycles = read_cycle_counter() - base_cycles;
    return ((uint64_t)base_unix_time * 1000000000ULL) + cycles_to_ns(delta_cycles);
}

/*
// Для замера времени
uint64_t start_ns() {
    if (base_cycles == 0) {
        base_cycles = read_cycle_counter();
    }
    uint64_t delta_cycles = read_cycle_counter() - base_cycles;
    return cycles_to_ns(delta_cycles); // полностью в наносекундах, без взятия по модулю
}

//printf("Elapsed: %ld ns\n", elapsed);                       // наносекунды
//printf("Elapsed: %.3f µs\n", (double)elapsed / 1000.0);    // микросекунды
//printf("Elapsed: %.3f ms\n", (double)elapsed / 1000000.0); // миллисекунды
//printf("Elapsed: %.6f s\n", (double)elapsed / 1000000000.0); // секунды

static void _stop_ms(char *buffer, size_t bufsize, uint64_t start_cycles) {
		uint64_t elapsed = start_ns() - start_cycles;

		snprintf(buffer, bufsize, "%.6f s", (uint64_t)elapsed / 1000000000.0);
}
*/
static void _stop_ms(char *buffer, size_t bufsize, uint64_t start_cycles) {
    uint64_t elapsed = start_ns() - start_cycles;
    snprintf(buffer, bufsize, "%.6f s", (double)elapsed / 1e9);
}


const char* stop_ms(uint64_t start_cycles) {
    static __thread char buf[21];
    _stop_ms(buf, sizeof(buf), start_cycles) ;
    return buf;
}

void GLOBAL_TIME(char *buffer, size_t bufsize) {
    uint64_t current_ns = start_ns();

    time_t seconds = current_ns / 1000000000ULL;
    uint64_t ns_part = current_ns % 1000000000ULL;

    struct tm tm_info;
    localtime_r(&seconds, &tm_info);
    strftime(buffer, bufsize, "%Y-%m-%d %H:%M:%S", &tm_info);

    size_t len = strlen(buffer);
    snprintf(buffer + len, bufsize - len, ".%09llu", (unsigned long long)ns_part);
}

/*
void GLOBAL_TIME(char *buffer, size_t bufsize) {
    uint64_t current_ns = start_ns();

    struct tm tm_info;
    time_t current_sec = time(NULL);
    localtime_r(&current_sec, &tm_info);
    strftime(buffer, bufsize, "%Y-%m-%d %H:%M:%S", &tm_info);

    size_t len = strlen(buffer);
		
		
    snprintf(buffer + len, bufsize - len, ".%.6f", (double)current_ns / 1e9 );
}
*/

const char* GLOBAL_TIME_PRINT() {
    static __thread char buf[64];
    GLOBAL_TIME(buf, sizeof(buf)) ;
    return buf;
}

int main() {
		for(int i=0;i<5;i++) {
		uint64_t start_time = start_ns();
		sleep(1);
		printf("%s: %d decode time: %s\r\n", 
			GLOBAL_TIME_PRINT(), 
			i, 
			stop_ms(start_time)
		);
		}

    return 0;
}