feat: harden codec lifecycle probes

Author: SaicharanKandukuri

src/android/fake-media-acceld.c

@@ -19,6 +19,7 @@
 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
+#include <time.h>
 #include <unistd.h>
 
 typedef bool (*binder_set_max_threads_fn)(uint32_t);
@@ -33,13 +34,26 @@ struct decoder_session {
     int pool_fd;
     uint8_t *pool_map;
     size_t pool_bytes;
-    bool slots[16];
+    bool slots[FMA_MAX_SLOTS];
     uint32_t next_slot;
     bool started;
+    uint32_t codec_id;
+    uint64_t packets;
+    uint64_t input_bytes;
+    uint64_t frames;
+    uint64_t frame_bytes;
+    uint64_t acquire_ns;
+    uint64_t copy_ns;
 };
 
 static volatile sig_atomic_t running = 1;
 
+static uint64_t monotonic_ns(void) {
+    struct timespec time;
+    return clock_gettime(CLOCK_MONOTONIC, &time) == 0 ?
+        (uint64_t)time.tv_sec * UINT64_C(1000000000) + (uint64_t)time.tv_nsec : 0;
+}
+
 static void on_signal(int signal_number) {
     (void)signal_number;
     running = 0;
@@ -86,6 +100,19 @@ static int send_error(int fd, const struct fma_message *request, const char *tex
 }
 
 static void destroy_decoder(struct decoder_session *session) {
+    if (session->packets) {
+        printf("metrics codec=%s packets=%llu input_bytes=%llu frames=%llu "
+               "frame_bytes=%llu acquire_ms=%.3f copy_ms=%.3f "
+               "socket_frame_bytes=0\n",
+               fma_codec_name(session->codec_id),
+               (unsigned long long)session->packets,
+               (unsigned long long)session->input_bytes,
+               (unsigned long long)session->frames,
+               (unsigned long long)session->frame_bytes,
+               (double)session->acquire_ns / 1000000.0,
+               (double)session->copy_ns / 1000000.0);
+        fflush(stdout);
+    }
     if (session->codec && session->started)
         AMediaCodec_stop(session->codec);
     if (session->codec)
@@ -122,6 +149,7 @@ static int create_decoder(struct decoder_session *session,
     const char *mime = fma_codec_mime(config->codec);
     if (!mime)
         return -1;
+    session->codec_id = config->codec;
 
     uint32_t stride = (config->width + 63u) & ~63u;
     session->pool = (struct fma_frame_pool) {
@@ -317,16 +345,25 @@ static int emit_output(int fd, const struct fma_message *request,
             AImage *image = NULL;
             uint32_t slot = UINT32_MAX;
             struct fma_frame frame;
-            if (find_free_slot(session, &slot) < 0 ||
-                acquire_image(session->reader, &image) < 0 ||
-                copy_image_to_nv12(image, session, slot, &frame) < 0) {
+            uint64_t started_ns = monotonic_ns();
+            int slot_status = find_free_slot(session, &slot);
+            int acquire_status = slot_status == 0 ?
+                acquire_image(session->reader, &image) : -1;
+            session->acquire_ns += monotonic_ns() - started_ns;
+            started_ns = monotonic_ns();
+            int copy_status = acquire_status == 0 ?
+                copy_image_to_nv12(image, session, slot, &frame) : -1;
+            session->copy_ns += monotonic_ns() - started_ns;
+            if (slot_status < 0 || acquire_status < 0 || copy_status < 0) {
                 if (image)
                     AImage_delete(image);
                 if (slot < session->pool.slot_count)
                     session->slots[slot] = false;
                 return -1;
             }
             AImage_delete(image);
+            session->frames++;
+            session->frame_bytes += frame.bytes_used;
             uint8_t payload[24];
             fma_encode_frame(&frame, payload);
             struct fma_message frame_request = *request;
@@ -438,6 +475,8 @@ static int serve_client(int fd) {
         case FMA_MSG_QUEUE_PACKET: {
             uint32_t flags = (request.flags & FMA_PACKET_CODEC_CONFIG) ?
                 AMEDIACODEC_BUFFER_FLAG_CODEC_CONFIG : 0;
+            session.packets++;
+            session.input_bytes += request.payload_size;
             if (!session.started || queue_input(&session, &request, flags) < 0 ||
                 emit_output(fd, &request, &session, 0, false) < 0)
                 result = send_error(fd, &request, "MediaCodec packet failed");

src/client/client.c

@@ -132,7 +132,14 @@ int fma_client_drain(struct fma_client *client) {
 }
 
 int fma_client_flush(struct fma_client *client) {
-    return send_simple(client, FMA_MSG_FLUSH, NULL, 0, 0, 0, NULL);
+    uint64_t request_id;
+    if (send_simple(client, FMA_MSG_FLUSH, NULL, 0, 0, 0, &request_id) < 0)
+        return -1;
+    struct fma_message reply;
+    if (expect(client, FMA_MSG_FLUSHED, request_id, &reply) < 0)
+        return -1;
+    fma_message_release(&reply);
+    return 0;
 }
 
 int fma_client_release_frame(struct fma_client *client, uint32_t slot) {

tests/fake-roundtrip.sh

@@ -18,7 +18,12 @@ while [ ! -S "$socket" ]; do
     sleep 0.01
 done
 
-"$decoder" "$socket" "$input" 64 64 30 "$output"
+result=$("$decoder" --repeat 3 "$socket" "$input" 64 64 30 "$output")
+printf '%s\n' "$result"
+case "$result" in
+    *"repeats=3 packets=3 frames=3 "*) ;;
+    *) exit 1 ;;
+esac
 wait "$daemon_pid"
 trap - EXIT INT TERM
 test -s "$output"

tests/protocol-test.c

@@ -46,6 +46,20 @@ static void test_rejects_bad_wire(void) {
     CHECK(errno == EPROTO);
 }
 
+static void test_rejects_unbounded_decoder(void) {
+    struct fma_decoder_config config = {
+        .codec = FMA_CODEC_H264,
+        .width = FMA_MAX_DIMENSION + 1,
+        .height = 1080,
+        .slot_count = FMA_DEFAULT_SLOTS,
+    };
+    uint8_t wire[16];
+    fma_encode_decoder_config(&config, wire);
+    struct fma_decoder_config decoded;
+    CHECK(fma_decode_decoder_config(wire, sizeof(wire), &decoded) == -1);
+    CHECK(errno == EINVAL);
+}
+
 static void test_payload_and_fd_roundtrip(void) {
     int sockets[2];
     CHECK(socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) == 0);
@@ -74,6 +88,7 @@ static void test_payload_and_fd_roundtrip(void) {
 int main(void) {
     test_header_roundtrip();
     test_rejects_bad_wire();
+    test_rejects_unbounded_decoder();
     test_payload_and_fd_roundtrip();
     puts("protocol tests passed");
     return 0;

tools/fma-decode.c

@@ -54,6 +54,7 @@ static int read_file(const char *path, uint8_t **data, size_t *size) {
 }
 
 static size_t find_access_units(const uint8_t *data, size_t size,
+                                uint32_t codec,
                                 struct access_unit **units_out) {
     size_t capacity = 64;
     size_t count = 0;
@@ -69,7 +70,12 @@ static size_t find_access_units(const uint8_t *data, size_t size,
         else if (i + 5 < size && data[i] == 0 && data[i + 1] == 0 &&
                  data[i + 2] == 0 && data[i + 3] == 1)
             start_code = 4;
-        if (!start_code || (data[i + start_code] & 0x1f) != 9)
+        if (!start_code)
+            continue;
+        uint32_t nal_type = codec == FMA_CODEC_HEVC ?
+            (data[i + start_code] >> 1) & 0x3f : data[i + start_code] & 0x1f;
+        uint32_t aud_type = codec == FMA_CODEC_HEVC ? 35u : 9u;
+        if (nal_type != aud_type)
             continue;
         if (found_aud) {
             if (count == capacity) {
@@ -98,6 +104,14 @@ static size_t find_access_units(const uint8_t *data, size_t size,
     return count;
 }
 
+static uint32_t parse_codec(const char *name) {
+    if (strcmp(name, "h264") == 0 || strcmp(name, "avc") == 0)
+        return FMA_CODEC_H264;
+    if (strcmp(name, "hevc") == 0 || strcmp(name, "h265") == 0)
+        return FMA_CODEC_HEVC;
+    return 0;
+}
+
 static int process_message(struct fma_client *client,
                            const struct fma_frame_pool *pool, uint8_t *pool_map,
                            FILE *output, uint64_t *frames, bool *packet_ack,
@@ -137,40 +151,59 @@ static int process_message(struct fma_client *client,
 }
 
 int main(int argc, char **argv) {
-    if (argc < 6 || argc > 7) {
-        fprintf(stderr, "usage: %s SOCKET INPUT.h264 WIDTH HEIGHT FPS [OUTPUT.nv12]\n",
-                argv[0]);
+    uint32_t codec = FMA_CODEC_H264;
+    uint32_t repeats = 1;
+    int argument = 1;
+    while (argument < argc && strncmp(argv[argument], "--", 2) == 0) {
+        if (strcmp(argv[argument], "--codec") == 0 && argument + 1 < argc) {
+            codec = parse_codec(argv[argument + 1]);
+            argument += 2;
+        } else if (strcmp(argv[argument], "--repeat") == 0 && argument + 1 < argc) {
+            repeats = (uint32_t)strtoul(argv[argument + 1], NULL, 10);
+            argument += 2;
+        } else {
+            codec = 0;
+            break;
+        }
+    }
+    int remaining = argc - argument;
+    if (!codec || !repeats || repeats > 1000 || remaining < 5 || remaining > 6) {
+        fprintf(stderr, "usage: %s [--codec h264|hevc] [--repeat N] "
+                "SOCKET INPUT WIDTH HEIGHT FPS [OUTPUT.nv12]\n", argv[0]);
         return 2;
     }
-    uint32_t width = (uint32_t)strtoul(argv[3], NULL, 10);
-    uint32_t height = (uint32_t)strtoul(argv[4], NULL, 10);
-    uint32_t fps = (uint32_t)strtoul(argv[5], NULL, 10);
+    const char *socket_path = argv[argument + 0];
+    const char *input_path = argv[argument + 1];
+    uint32_t width = (uint32_t)strtoul(argv[argument + 2], NULL, 10);
+    uint32_t height = (uint32_t)strtoul(argv[argument + 3], NULL, 10);
+    uint32_t fps = (uint32_t)strtoul(argv[argument + 4], NULL, 10);
+    const char *output_path = remaining == 6 ? argv[argument + 5] : NULL;
     if (!width || !height || !fps)
         return 2;
 
     uint8_t *input = NULL;
     size_t input_size = 0;
-    if (read_file(argv[2], &input, &input_size) < 0) {
+    if (read_file(input_path, &input, &input_size) < 0) {
         perror("input");
         return 1;
     }
     struct access_unit *units = NULL;
-    size_t unit_count = find_access_units(input, input_size, &units);
+    size_t unit_count = find_access_units(input, input_size, codec, &units);
     if (!unit_count) {
         fprintf(stderr, "could not split input\n");
         free(input);
         return 1;
     }
 
     struct fma_client client;
-    if (fma_client_connect(&client, argv[1]) < 0) {
+    if (fma_client_connect(&client, socket_path) < 0) {
         perror("connect");
         free(units);
         free(input);
         return 1;
     }
     struct fma_decoder_config config = {
-        .codec = FMA_CODEC_H264, .width = width, .height = height,
+        .codec = codec, .width = width, .height = height,
         .slot_count = FMA_DEFAULT_SLOTS,
     };
     struct fma_frame_pool pool;
@@ -192,8 +225,8 @@ int main(int argc, char **argv) {
         free(input);
         return 1;
     }
-    FILE *output = argc == 7 ? fopen(argv[6], "wb") : NULL;
-    if (argc == 7 && !output) {
+    FILE *output = output_path ? fopen(output_path, "wb") : NULL;
+    if (output_path && !output) {
         perror("output");
         return 1;
     }
@@ -204,35 +237,46 @@ int main(int argc, char **argv) {
     uint64_t started_ns = monotonic_ns();
     bool eos = false;
     bool failed = false;
-    for (size_t i = 0; i < unit_count; ++i) {
-        int64_t pts_us = (int64_t)(i * UINT64_C(1000000) / fps);
-        bool packet_ack = false;
-        if (fma_client_queue_packet(&client, input + units[i].offset,
-                                    units[i].size, pts_us, 0) < 0) {
-            perror("decode");
-            failed = true;
-            break;
+    for (uint32_t repeat = 0; repeat < repeats && !failed; ++repeat) {
+        eos = false;
+        for (size_t i = 0; i < unit_count; ++i) {
+            int64_t pts_us = (int64_t)(i * UINT64_C(1000000) / fps);
+            bool packet_ack = false;
+            if (fma_client_queue_packet(&client, input + units[i].offset,
+                                        units[i].size, pts_us, 0) < 0) {
+                perror("decode");
+                failed = true;
+                break;
+            }
+            input_bytes += units[i].size;
+            while (!packet_ack &&
+                   process_message(&client, &pool, pool_map, output, &frames,
+                                   &packet_ack, &eos) == 0) {}
+            if (!packet_ack) {
+                perror("decode");
+                failed = true;
+                break;
+            }
         }
-        input_bytes += units[i].size;
-        while (!packet_ack &&
-               process_message(&client, &pool, pool_map, output, &frames,
-                               &packet_ack, &eos) == 0) {}
-        if (!packet_ack) {
-            perror("decode");
+        if (!failed && fma_client_drain(&client) == 0) {
+            bool packet_ack = false;
+            while (!eos && process_message(&client, &pool, pool_map, output,
+                                           &frames, &packet_ack, &eos) == 0) {}
+        }
+        if (!eos)
+            failed = true;
+        if (!failed && repeat + 1 < repeats && fma_client_flush(&client) < 0) {
+            perror("flush");
             failed = true;
-            break;
         }
     }
-    if (!failed && fma_client_drain(&client) == 0) {
-        bool packet_ack = false;
-        while (!eos && process_message(&client, &pool, pool_map, output,
-                                       &frames, &packet_ack, &eos) == 0) {}
-    }
     uint64_t elapsed_ns = monotonic_ns() - started_ns;
     frame_bytes = frames * pool.slot_size;
     double seconds = elapsed_ns ? (double)elapsed_ns / 1000000000.0 : 0.0;
-    printf("packets=%zu frames=%llu elapsed_ms=%.3f decode_fps=%.2f\n",
-           unit_count, (unsigned long long)frames, seconds * 1000.0,
+    printf("codec=%s repeats=%u packets=%zu frames=%llu elapsed_ms=%.3f "
+           "decode_fps=%.2f\n",
+           fma_codec_name(codec), repeats, unit_count * (size_t)repeats,
+           (unsigned long long)frames, seconds * 1000.0,
            seconds > 0.0 ? (double)frames / seconds : 0.0);
     printf("compressed_bytes=%llu frame_bytes=%llu shared_pool_bytes=%zu "
            "socket_frame_bytes=0\n",