ret = rknn_init(&ctx, model, model_size, 0, NULL);
    free(model);
    if (ret < 0) {
        printf("RKNN-Initialisierung fehlgeschlagen: %d\n", ret);
        return -1;
    }
    
    // RKNN-Eingabe-Attribute abrufen
    rknn_input_output_num io_num;
    ret = rknn_query(ctx, RKNN_QUERY_IN_OUT_NUM, &io_num, sizeof(io_num));
    if (ret < 0) {
        printf("RKNN-Abfrage fehlgeschlagen: %d\n", ret);
        rknn_destroy(ctx);
        return -1;
    }
    printf("Modell hat %d Eingaben und %d Ausgaben\n", io_num.n_input, io_num.n_output);
    
    // Eingabe-Tensoren konfigurieren
    rknn_tensor_attr input_attrs[io_num.n_input];
    memset(input_attrs, 0, sizeof(input_attrs));
    for (int i = 0; i < io_num.n_input; i++) {
        input_attrs[i].index = i;
        ret = rknn_query(ctx, RKNN_QUERY_INPUT_ATTR, &input_attrs[i], sizeof(rknn_tensor_attr));
        if (ret < 0) {
            printf("RKNN-Eingabe-Attribut-Abfrage fehlgeschlagen: %d\n", ret);
            rknn_destroy(ctx);
            return -1;
        }
    }
    
    // Ausgabe-Tensoren konfigurieren
    rknn_tensor_attr output_attrs[io_num.n_output];
    memset(output_attrs, 0, sizeof(output_attrs));
    for (int i = 0; i < io_num.n_output; i++) {
        output_attrs[i].index = i;
        ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &output_attrs[i], sizeof(rknn_tensor_attr));
        if (ret < 0) {
            printf("RKNN-Ausgabe-Attribut-Abfrage fehlgeschlagen: %d\n", ret);
            rknn_destroy(ctx);
            return -1;
        }
    }
    
    // Eingabe-Tensor-Dimensionen anzeigen
    printf("Eingabe-Tensoren:\n");
    for (int i = 0; i < io_num.n_input; i++) {
        printf("  Eingabe %d: Größe=%d, Typ=%d, Dimensionen=%d %d %d %d\n", 
               i, input_attrs[i].size, input_attrs[i].type, 
               input_attrs[i].dim[0], input_attrs[i].dim[1], 
               input_attrs[i].dim[2], input_attrs[i].dim[3]);
    }
    
    // Ausgabe-Tensor-Dimensionen anzeigen
    printf("Ausgabe-Tensoren:\n");
    for (int i = 0; i < io_num.n_output; i++) {
        printf("  Ausgabe %d: Größe=%d, Typ=%d, Dimensionen=%d %d %d %d\n", 
               i, output_attrs[i].size, output_attrs[i].type, 
               output_attrs[i].dim[0], output_attrs[i].dim[1], 
               output_attrs[i].dim[2], output_attrs[i].dim[3]);
    }
    
    // Bild laden
    int img_width, img_height, img_channels;
    unsigned char* img_data = load_image("test.jpg", &img_width, &img_height, &img_channels);
    if (!img_data) {
        printf("Bild laden fehlgeschlagen\n");
        rknn_destroy(ctx);
        return -1;
    }
    
    // Eingaben vorbereiten
    rknn_input inputs[1];
    memset(inputs, 0, sizeof(inputs));
    inputs[0].index = 0;
    inputs[0].type = RKNN_TENSOR_UINT8;
    inputs[0].size = img_width * img_height * img_channels;
    inputs[0].fmt = RKNN_TENSOR_NHWC;
    inputs[0].buf = img_data;
    
    // Eingaben setzen
    ret = rknn_inputs_set(ctx, io_num.n_input, inputs);
    if (ret < 0) {
        printf("RKNN-Eingaben setzen fehlgeschlagen: %d\n", ret);
        free(img_data);
        rknn_destroy(ctx);
        return -1;
    }
    
    // Inferenz durchführen
    printf("Inferenz läuft...\n");
    ret = rknn_run(ctx, NULL);
    if (ret < 0) {
        printf("RKNN-Ausführung fehlgeschlagen: %d\n", ret);
        free(img_data);
        rknn_destroy(ctx);
        return -1;
    }
    
    // Ausgaben abrufen
    rknn_output outputs[io_num.n_output];
    memset(outputs, 0, sizeof(outputs));
    for (int i = 0; i < io_num.n_output; i++) {
        outputs[i].want_float = 1;
    }
    
    ret = rknn_outputs_get(ctx, io_num.n_output, outputs, NULL);
    if (ret < 0) {
        printf("RKNN-Ausgaben abrufen fehlgeschlagen: %d\n", ret);
        free(img_data);
        rknn_destroy(ctx);
        return -1;
    }
    
    // Top 5 Ergebnisse (für Klassifikationsmodell) finden
    for (int i = 0; i < io_num.n_output; i++) {
        float* output_buffer = (float*)outputs[i].buf;
        uint32_t output_size = outputs[i].size / sizeof(float);
        
        printf("Top 5 Klassifikationsergebnisse:\n");
        for (int j = 0; j < 5 && j < output_size; j++) {
            float max_value = -1000.0f;
            int max_index = -1;
            
            // Maximum finden
            for (uint32_t k = 0; k < output_size; k++) {
                if (output_buffer[k] > max_value) {
                    max_value = output_buffer[k];
                    max_index = k;
                }
            }
            
            // Ergebnis anzeigen und Maximum entfernen für nächste Iteration
            printf("  %d: Index=%d, Wert=%f\n", j, max_index, max_value);
            output_buffer[max_index] = -1000.0f;
        }
    }
    
    // Ausgaben freigeben
    rknn_outputs_release(ctx, io_num.n_output, outputs);
    
    // Aufräumen
    free(img_data);
    rknn_destroy(ctx);
    
    return 0;
}

// TensorFlow Lite mit RKNN-Delegaten
#include <iostream>
#include <cstdlib>
#include <tensorflow/lite/interpreter.h>
#include <tensorflow/lite/kernels/register.h>
#include <tensorflow/lite/model.h>
#include <tensorflow/lite/delegates/rknn/rknn_delegate.h>

int main(int argc, char* argv[]) {
    if (argc != 2) {
        std::cerr << "Verwendung: " << argv[0] << " <tflite_modell_pfad>" << std::endl;
        return EXIT_FAILURE;
    }
    
    const char* model_path = argv[1];
    
    // Modell laden
    std::unique_ptr<tflite::FlatBufferModel> model =
        tflite::FlatBufferModel::BuildFromFile(model_path);
    if (!model) {
        std::cerr << "Fehler beim Laden des TFLite-Modells" << std::endl;
        return EXIT_FAILURE;
    }
    
    // Resolver erstellen
    tflite::ops::builtin::BuiltinOpResolver resolver;
    
    // Interpreter erstellen
    std::unique_ptr<tflite::Interpreter> interpreter;
    tflite::InterpreterBuilder(*model, resolver)(&interpreter);
    if (!interpreter) {
        std::cerr << "Fehler beim Erstellen des Interpreters" << std::endl;
        return EXIT_FAILURE;
    }
    
    // RKNN-Delegaten erstellen
    TfLiteRKNNDelegateOptions options = TfLiteRKNNDelegateOptionsDefault();
    options.execution_priority = RKNN_PRIORITY_HIGH;
    options.cache_path = "/data/rknn/cache";
    
    TfLiteDelegate* rknn_delegate = TfLiteRKNNDelegateCreate(&options);
    if (interpreter->ModifyGraphWithDelegate(rknn_delegate) != kTfLiteOk) {
        std::cerr << "Fehler beim Anwenden des RKNN-Delegaten" << std::endl;
        TfLiteRKNNDelegateDelete(rknn_delegate);
        return EXIT_FAILURE;
    }
    
    // Tensor-Größen zuweisen
    if (interpreter->AllocateTensors() != kTfLiteOk) {
        std::cerr << "Fehler beim Zuweisen der Tensoren" << std::endl;
        TfLiteRKNNDelegateDelete(rknn_delegate);
        return EXIT_FAILURE;
    }
    
    // Eingabetensor abrufen
    TfLiteTensor* input_tensor = interpreter->input_tensor(0);
    
    // Beispiel-Eingabedaten erstellen (alle auf 0.5 setzen)
    int input_size = 1;
    for (int i = 0; i < input_tensor->dims->size; i++) {
        input_size *= input_tensor->dims->data[i];
    }
    
    if (input_tensor->type == kTfLiteFloat32) {
        float* input_data = interpreter->typed_input_tensor<float>(0);
        for (int i = 0; i < input_size; i++) {
            input_data[i] = 0.5f;
        }
    } else if (input_tensor->type == kTfLiteUInt8) {
        uint8_t* input_data = interpreter->typed_input_tensor<uint8_t>(0);
        for (int i = 0; i < input_size; i++) {
            input_data[i] = 128;
        }
    } else {
        std::cerr << "Nicht unterstützter Eingabetyp" << std::endl;
        TfLiteRKNNDelegateDelete(rknn_delegate);
        return EXIT_FAILURE;
    }
    
    // Inferenz durchführen
    if (interpreter->Invoke() != kTfLiteOk) {
        std::cerr << "Fehler bei der Inferenz" << std::endl;
        TfLiteRKNNDelegateDelete(rknn_delegate);
        return EXIT_FAILURE;
    }
    
    // Ausgabetensor abrufen
    TfLiteTensor* output_tensor = interpreter->output_tensor(0);
    
    // Ergebnisse ausgeben
    if (output_tensor->type == kTfLiteFloat32) {
        float* output_data = interpreter->typed_output_tensor<float>(0);
        int output_size = 1;
        for (int i = 0; i < output_tensor->dims->size; i++) {
            output_size *= output_tensor->dims->data[i];
        }
        
        std::cout << "Ausgabe (erste 10 Werte):" << std::endl;
        for (int i = 0; i < 10 && i < output_size; i++) {
            std::cout << "  [" << i << "]: " << output_data[i] << std::endl;
        }
    }
    
    // Delegaten freigeben
    TfLiteRKNNDelegateDelete(rknn_delegate);
    
    return EXIT_SUCCESS;
}

// Video-Dekodierungsbeispiel mit MPP
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <rockchip/rk_mpi.h>

#define MAX_FRAME_SIZE (8 * 1024 * 1024)  // 8MB für einen Frame

int main(int argc, char** argv) {
    if (argc < 3) {
        printf("Verwendung: %s <eingang.h264> <ausgang.yuv>\n", argv[0]);
        return -1;
    }
    
    // MPP-Kontext
    MppCtx ctx;
    MppApi *mpi;
    
    // Input/Output Dateien
    FILE *input_file = fopen(argv[1], "rb");
    FILE *output_file = fopen(argv[2], "wb");
    if (!input_file || !output_file) {
        printf("Fehler beim Öffnen der Dateien\n");
        return -1;
    }
    
    // MPP initialisieren
    MPP_RET ret = mpp_create(&ctx, &mpi);
    if (ret != MPP_OK) {
        printf("MPP erstellen fehlgeschlagen: %d\n", ret);
        return -1;
    }
    
    // Dekoder initialisieren
    ret = mpi->control(ctx, MPP_SET_OUTPUT_TIMEOUT, (MppParam)&timeout);
    if (ret != MPP_OK) {
        printf("Timeout setzen fehlgeschlagen: %d\n", ret);
        goto CLEANUP;
    }
    
    // Decoder konfigurieren
    MppCodingType codec_type = MPP_VIDEO_CodingAVC; // H.264
    ret = mpi->control(ctx, MPP_DEC_SET_CODING_TYPE, &codec_type);
    if (ret != MPP_OK) {
        printf("Codec-Typ setzen fehlgeschlagen: %d\n", ret);
        goto CLEANUP;
    }
    
    // Decoder initialisieren
    ret = mpi->init(ctx, MPP_CTX_DEC, codec_type);
    if (ret != MPP_OK) {
        printf("MPP initialisieren fehlgeschlagen: %d\n", ret);
        goto CLEANUP;
    }
    
    // Eingabe-Puffer für Rohdaten
    void *input_buffer = malloc(MAX_FRAME_SIZE);
    if (!input_buffer) {
        printf("Speicherallokation fehlgeschlagen\n");
        goto CLEANUP;
    }
    
    // Paket für Dekodierung
    MppPacket packet;
    
    // Frame für dekodierte Ausgabe
    MppFrame frame = NULL;
    
    // Video-Stream dekodieren
    size_t read_size;
    size_t packet_size = 0;
    while ((read_size = fread(input_buffer + packet_size, 1, 4096, input_file)) > 0) {
        packet_size += read_size;
        
        // Paket erstellen
        ret = mpp_packet_init(&packet, input_buffer, packet_size);
        if (ret != MPP_OK) {
            printf("Paket initialisieren fehlgeschlagen: %d\n", ret);
            break;
        }
        
        // Paket an Decoder senden
        ret = mpi->decode_put_packet(ctx, packet);
        if (ret != MPP_OK) {
            printf("Paket senden fehlgeschlagen: %d\n", ret);
            mpp_packet_deinit(&packet);
            break;
        }
        
        mpp_packet_deinit(&packet);
        
        // Dekodierte Frames abrufen
        do {
            ret = mpi->decode_get_frame(ctx, &frame);
            if (ret != MPP_OK) {
                printf("Frame abrufen fehlgeschlagen: %d\n", ret);
                break;
            }
            
            if (frame) {
                // Prüfen, ob Frame gültig ist
                if (mpp_frame_get_errinfo(frame)) {
                    printf("Frame hat Fehler\n");
                    mpp_frame_deinit(&frame);
                    continue;
                }
                
                // Frame-Informationen abrufen
                MppBuffer buffer = mpp_frame_get_buffer(frame);
                if (buffer) {
                    void *ptr = mpp_buffer_get_ptr(buffer);
                    size_t size = mpp_buffer_get_size(buffer);
                    int width = mpp_frame_get_width(frame);
                    int height = mpp_frame_get_height(frame);
                    MppFrameFormat fmt = mpp_frame_get_fmt(frame);
                    
                    printf("Dekodierter Frame: %dx%d, Format=%d\n", width, height, fmt);
                    
                    // YUV-Daten in Ausgabedatei schreiben
                    fwrite(ptr, 1, size, output_file);
                }
                
                // Frame freigeben
                mpp_frame_deinit(&frame);
                frame = NULL;
            }
        } while (frame);
        
        // Puffer zurücksetzen für nächstes Paket
        packet_size = 0;
    }
    
    // Aufräumen
    free(input_buffer);
    
CLEANUP:
    if (ctx) {
        mpi->reset(ctx);
        mpp_destroy(ctx);
        ctx = NULL;
    }
    
    if (input_file) fclose(input_file);
    if (output_file) fclose(output_file);
    
    return 0;
}

// V4L2-Kamera-Beispiel
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <linux/videodev2.h>

#define CAMERA_DEVICE "/dev/video0"
#define BUFFER_COUNT 4
#define FRAME_WIDTH 1920
#define FRAME_HEIGHT 1080
#define PIXEL_FORMAT V4L2_PIX_FMT_YUYV

struct buffer {
    void *start;
    size_t length;
};

int main() {
    int fd;
    struct buffer *buffers;
    
    // Kamera-Gerät öffnen
    fd = open(CAMERA_DEVICE, O_RDWR);
    if (fd < 0) {
        perror("Kamera öffnen fehlgeschlagen");
        return EXIT_FAILURE;
    }
    
    // Kamera-Fähigkeiten abfragen
    struct v4l2_capability cap;
    if (ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {
        perror("Kamera-Fähigkeiten abfragen fehlgeschlagen");
        close(fd);
        return EXIT_FAILURE;
    }
    
    if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
        fprintf(stderr, "Gerät unterstützt keine Videoaufnahme\n");
        close(fd);
        return EXIT_FAILURE;
    }
    
    if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
        fprintf(stderr, "Gerät unterstützt kein Streaming\n");
        close(fd);
        return EXIT_FAILURE;
    }
    
    // Videoformat einstellen
    struct v4l2_format fmt;
    memset(&fmt, 0, sizeof(fmt));
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width = FRAME_WIDTH;
    fmt.fmt.pix.height = FRAME_HEIGHT;
    fmt.fmt.pix.pixelformat = PIXEL_FORMAT;
    fmt.fmt.pix.field = V4L2_FIELD_ANY;
    
    if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) {
        perror("Videoformat einstellen fehlgeschlagen");
        close(fd);
        return EXIT_FAILURE;
    }
    
    // Buffer anfordern
    struct v4l2_requestbuffers req;
    memset(&req, 0, sizeof(req));
    req.count = BUFFER_COUNT;
    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    req.memory = V4L2_MEMORY_MMAP;
    
    if (ioctl(fd, VIDIOC_REQBUFS, &req) < 0) {
        perror("Buffer anfordern fehlgeschlagen");
        close(fd);
        return EXIT_FAILURE;
    }
    
    if (req.count < 2) {
        fprintf(stderr, "Nicht genug Pufferspeicher\n");
        close(fd);
        return EXIT_FAILURE;
    }
    
    // Buffer allozieren
    buffers = calloc(req.count, sizeof(*buffers));
    if (!buffers) {
        perror("Speicherallokation fehlgeschlagen");
        close(fd);
        return EXIT_FAILURE;
    }
    
    // Buffer Memory-Map durchführen
    for (unsigned int i = 0; i < req.count; i++) {
        struct v4l2_buffer buf;
        memset(&buf, 0, sizeof(buf));
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index = i;
        
        if (ioctl(fd, VIDIOC_QUERYBUF, &buf) < 0) {
            perror("Buffer-Info abfragen fehlgeschlagen");
            close(fd);
            free(buffers);
            return EXIT_FAILURE;
        }
        
        buffers[i].length = buf.length;
        buffers[i].start = mmap(NULL, buf.length, PROT_READ | PROT_WRITE,
                              MAP_SHARED, fd, buf.m.offset);
        
        if (buffers[i].start == MAP_FAILED) {
            perror("Memory-Map fehlgeschlagen");
            close(fd);
            free(buffers);
            return EXIT_FAILURE;
        }
    }
    
    // Buffer zur Warteschlange hinzufügen
    for (unsigned int i = 0; i < req.count; i++) {
        struct v4l2_buffer buf;
        memset(&buf, 0, sizeof(buf));
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index = i;
        
        if (ioctl(fd, VIDIOC_QBUF, &buf) < 0) {
            perror("Buffer zur Warteschlange hinzufügen fehlgeschlagen");
            close(fd);
            free(buffers);
            return EXIT_FAILURE;
        }
    }
    
    // Streaming starten
    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    if (ioctl(fd, VIDIOC_STREAMON, &type) < 0) {
        perror("Streaming starten fehlgeschlagen");
        close(fd);
        free(buffers);
        return EXIT_FAILURE;
    }
    
    // 10 Frames erfassen
    for (int i = 0; i < 10; i++) {
        struct v4l2_buffer buf;
        memset(&buf, 0, sizeof(buf));
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        
        // Buffer aus der Warteschlange holen
        if (ioctl(fd, VIDIOC_DQBUF, &buf) < 0) {
            perror("Buffer aus der Warteschlange holen fehlgeschlagen");
            break;
        }
        
        printf("Frame %d erfasst: %ld Bytes\n", i, buffers[buf.index].length);
        
        // Hier könnten Sie die Bilddaten verarbeiten
        // z.B. in eine Datei schreiben:
        char filename[20];
        sprintf(filename, "frame%d.raw", i);
        FILE *fp = fopen(filename, "wb");
        if (fp) {
            fwrite(buffers[buf.index].start, 1, buffers[buf.index].length, fp);
            fclose(fp);
        }
        
        // Buffer wieder in die Warteschlange stellen
        if (ioctl(fd, VIDIOC_QBUF, &buf) < 0) {
            perror("Buffer zurück in die Warteschlange stellen fehlgeschlagen");
            break;
        }
    }
    
    // Streaming stoppen
    if (ioctl(fd, VIDIOC_STREAMOFF, &type) < 0) {
        perror("Streaming stoppen fehlgeschlagen");
    }
    
    // Aufräumen
    for (unsigned int i = 0; i < req.count; i++) {
        munmap(buffers[i].start, buffers[i].length);
    }
    
    free(buffers);
    close(fd);
    
    return EXIT_SUCCESS;
}