Support compiling and running C from JavaScript

[Jarred-Sumner]

What does this PR do?

This adds a cc function in bun:ffi which directly exposes TinyCC (a C compiler) and lets you run the code.

An example program below converts a file to .mp4 using ffmpeg's API. Converting a 20 MB .mov file to .mp4 this method takes about 13ms per invocation, but ffmpeg -i node-1.mov -c:v copy node-1.mp4 takes 34ms, likely due to start time overhead.

script:

❯ bun-debug mp4.js node-1.mov
[27.54ms] Compile ./mp4.c
[13.31ms] Convert node-1.mov to /Users/jarred/Desktop/node-1.mp4
[10.47ms] Convert node-1.mov to /Users/jarred/Desktop/node-1.mp4
[10.40ms] Convert node-1.mov to /Users/jarred/Desktop/node-1.mp4
[10.62ms] Convert node-1.mov to /Users/jarred/Desktop/node-1.mp4
[10.49ms] Convert node-1.mov to /Users/jarred/Desktop/node-1.mp4
[10.39ms] Convert node-1.mov to /Users/jarred/Desktop/node-1.mp4
[10.72ms] Convert node-1.mov to /Users/jarred/Desktop/node-1.mp4
[10.47ms] Convert node-1.mov to /Users/jarred/Desktop/node-1.mp4
[10.26ms] Convert node-1.mov to /Users/jarred/Desktop/node-1.mp4
[10.17ms] Convert node-1.mov to /Users/jarred/Desktop/node-1.mp4

ffmpeg cli:

❯ hyperfine "ffmpeg -i node-1.mov -c:v copy node-1.mp4 -y"
Benchmark 1: ffmpeg -i node-1.mov -c:v copy node-1.mp4 -y
  Time (mean ± σ):      36.8 ms ±   2.3 ms    [User: 21.6 ms, System: 14.7 ms]
  Range (min … max):    34.2 ms …  44.4 ms    79 runs

import { cc, ptr } from "bun:ffi";
import source from './mp4.c' with {type: 'file'};
import { basename, extname, join } from "path";

console.time(`Compile ./mp4.c`)
const {
  symbols: { convert_file_to_mp4 },
} = cc({
  source,
  library: ["c", "avcodec", "swscale", "avformat"],
  symbols: {
    convert_file_to_mp4: {
      returns: "int",
      args: ["cstring", "cstring"],
    },
  },
});
console.timeEnd(`Compile ./mp4.c`)
const outname = join(process.cwd(), basename(process.argv.at(2), extname(process.argv.at(2))) + ".mp4");
const input = Buffer.from(process.argv.at(2) + "\0");
const output = Buffer.from(outname + "\0");
for (let i = 0; i < 10; i++) {
console.time(`Convert ${process.argv.at(2)} to ${outname}`);
const result = convert_file_to_mp4(ptr(input), ptr(output));
if (result == 0) {
  console.timeEnd(`Convert ${process.argv.at(2)} to ${outname}`);
}
}

C (this was generated by claude)

#include <dlfcn.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/avutil.h>
#include <libavutil/imgutils.h>
#include <libavutil/opt.h>
#include <libswscale/swscale.h>
#include <stdio.h>
#include <stdlib.h>

int to_mp4(void *buf, size_t buflen, void **out, size_t *outlen) {
  AVFormatContext *input_ctx = NULL, *output_ctx = NULL;
  AVIOContext *input_io_ctx = NULL, *output_io_ctx = NULL;
  uint8_t *output_buffer = NULL;
  int ret = 0;
  int64_t *last_dts = NULL;

  // Register all codecs and formats

  // Create input IO context
  input_io_ctx = avio_alloc_context(buf, buflen, 0, NULL, NULL, NULL, NULL);
  if (!input_io_ctx) {
    ret = AVERROR(ENOMEM);
    goto end;
  }

  // Allocate input format context
  input_ctx = avformat_alloc_context();
  if (!input_ctx) {
    ret = AVERROR(ENOMEM);
    goto end;
  }

  input_ctx->pb = input_io_ctx;

  // Open input
  if ((ret = avformat_open_input(&input_ctx, NULL, NULL, NULL)) < 0) {
    goto end;
  }

  // Retrieve stream information
  if ((ret = avformat_find_stream_info(input_ctx, NULL)) < 0) {
    goto end;
  }

  // Allocate output format context
  avformat_alloc_output_context2(&output_ctx, NULL, "mp4", NULL);
  if (!output_ctx) {
    ret = AVERROR(ENOMEM);
    goto end;
  }

  // Create output IO context
  ret = avio_open_dyn_buf(&output_ctx->pb);
  if (ret < 0) {
    goto end;
  }

  // Copy streams
  for (int i = 0; i < input_ctx->nb_streams; i++) {
    AVStream *in_stream = input_ctx->streams[i];
    AVStream *out_stream = avformat_new_stream(output_ctx, NULL);
    if (!out_stream) {
      ret = AVERROR(ENOMEM);
      goto end;
    }

    ret = avcodec_parameters_copy(out_stream->codecpar, in_stream->codecpar);
    if (ret < 0) {
      goto end;
    }
    out_stream->codecpar->codec_tag = 0;
  }

  // Write header
  ret = avformat_write_header(output_ctx, NULL);
  if (ret < 0) {
    goto end;
  }

  // Allocate last_dts array
  last_dts = calloc(input_ctx->nb_streams, sizeof(int64_t));
  if (!last_dts) {
    ret = AVERROR(ENOMEM);
    goto end;
  }

  // Copy packets
  AVPacket pkt;
  while (1) {
    ret = av_read_frame(input_ctx, &pkt);
    if (ret < 0) {
      break;
    }

    AVStream *in_stream = input_ctx->streams[pkt.stream_index];
    AVStream *out_stream = output_ctx->streams[pkt.stream_index];

    // Convert timestamps
    pkt.pts =
        av_rescale_q_rnd(pkt.pts, in_stream->time_base, out_stream->time_base,
                         AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX);
    pkt.dts =
        av_rescale_q_rnd(pkt.dts, in_stream->time_base, out_stream->time_base,
                         AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX);
    pkt.duration =
        av_rescale_q(pkt.duration, in_stream->time_base, out_stream->time_base);

    // Ensure monotonically increasing DTS
    if (pkt.dts <= last_dts[pkt.stream_index]) {
      pkt.dts = last_dts[pkt.stream_index] + 1;
      pkt.pts = FFMAX(pkt.pts, pkt.dts);
    }
    last_dts[pkt.stream_index] = pkt.dts;

    pkt.pos = -1;

    ret = av_interleaved_write_frame(output_ctx, &pkt);
    if (ret < 0) {
      char errbuf[AV_ERROR_MAX_STRING_SIZE];
      av_strerror(ret, errbuf, AV_ERROR_MAX_STRING_SIZE);
      fprintf(stderr, "Error writing frame: %s\n", errbuf);
      break;
    }
    av_packet_unref(&pkt);
  }

  // Write trailer
  ret = av_write_trailer(output_ctx);
  if (ret < 0) {
    goto end;
  }

  // Get the output buffer
  *outlen = avio_close_dyn_buf(output_ctx->pb, &output_buffer);
  *out = output_buffer;
  output_ctx->pb = NULL; // Set to NULL to prevent double free

  ret = 0; // Success

end:
  if (input_ctx) {
    avformat_close_input(&input_ctx);
  }
  if (output_ctx) {
    avformat_free_context(output_ctx);
  }
  if (input_io_ctx) {
    av_freep(&input_io_ctx->buffer);
    av_freep(&input_io_ctx);
  }

  return ret;
}

int convert_file_to_mp4(const char *input_filename,
                        const char *output_filename) {
  FILE *input_file = NULL;
  FILE *output_file = NULL;
  uint8_t *input_buffer = NULL;
  uint8_t *output_buffer = NULL;
  size_t input_size = 0;
  size_t output_size = 0;
  int ret = 0;

  // Open the input file
  input_file = fopen(input_filename, "rb");
  if (!input_file) {
    perror("Could not open input file");
    return -1;
  }

  // Get the size of the input file
  fseek(input_file, 0, SEEK_END);
  input_size = ftell(input_file);
  fseek(input_file, 0, SEEK_SET);

  // Allocate memory for the input buffer
  input_buffer = (uint8_t *)malloc(input_size);
  if (!input_buffer) {
    perror("Could not allocate input buffer");
    ret = -1;
    goto cleanup;
  }

  // Read the input file into the buffer
  if (fread(input_buffer, 1, input_size, input_file) != input_size) {
    perror("Could not read input file");
    ret = -1;
    goto cleanup;
  }

  // Call the to_mp4 function to convert the buffer
  ret = to_mp4(input_buffer, input_size, (void **)&output_buffer, &output_size);
  if (ret < 0) {
    fprintf(stderr, "Error converting to MP4\n");
    goto cleanup;
  }

  // Open the output file
  output_file = fopen(output_filename, "wb");
  if (!output_file) {
    perror("Could not open output file");
    ret = -1;
    goto cleanup;
  }

  // Write the output buffer to the file
  if (fwrite(output_buffer, 1, output_size, output_file) != output_size) {
    perror("Could not write output file");
    ret = -1;
    goto cleanup;
  }

cleanup:

  if (output_buffer) {
    av_free(output_buffer);
  }
  if (input_file) {
    fclose(input_file);
  }
  if (output_file) {
    fclose(output_file);
  }

  return ret;
}

// for running it standalone
int main(const int argc, const char **argv) {

  if (argc != 3) {
    printf("Usage: %s <input_file> <output_file>\n", argv[0]);
    return -1;
  }

  const char *input_filename = argv[1];
  const char *output_filename = argv[2];

  int result = convert_file_to_mp4(input_filename, output_filename);
  if (result == 0) {
    printf("Conversion successful!\n");
  } else {
    printf("Conversion failed!\n");
  }
  return result;
}

This program below which includes 144 header files compiles in about 30ms in a debug build on an M1.

How did you verify your code works?

[robobun]

❌ @Jarred-Sumner, your commit 5940b6f has 12 failures in #3522:

test/integration/next-pages/test/dev-server.test.ts - 1 failing on 🍎 14 x64

test/js/node/child_process/child_process.test.ts - 1 failing on 🪟 x64-baseline

test/js/web/streams/streams.test.js - 1 failing on 🍎 13 x64

test/js/web/streams/streams.test.js - 1 failing on 🍎 14 x64

test/js/web/fetch/fetch-preconnect.test.ts - 1 failing on 🍎 13 aarch64

test/js/web/fetch/fetch-tcp-stress.test.ts - timeout on 🍎 13 aarch64

test/napi/napi.test.ts - 1 failing on 🪟 x64

test/napi/napi.test.ts - 1 failing on 🪟 x64-baseline

test/cli/hot/watch.test.ts - 1 failing on 🪟 x64

test/cli/hot/watch.test.ts - 1 failing on 🪟 x64-baseline

test/js/bun/http/fetch-file-upload.test.ts - 1 failing on 🪟 x64-baseline

test/cli/watch/watch.test.ts - 2 failing on 🪟 x64-baseline

test/cli/watch/watch.test.ts - 2 failing on 🪟 x64

test/bundler/bun-build-api.test.ts - 1 failing on 🪟 x64

test/bundler/bun-build-api.test.ts - 1 failing on 🪟 x64-baseline

test/cli/install/registry/bun-install-registry.test.ts - 1 failing on 🍎 13 x64

test/js/node/test/parallel/child-process-exec-timeout-kill.test.js - 1 failing on 🍎 14 aarch64

[paperclover]

amazing proof of concept.

i still think the header parsing issue is a solvable skill issue and that should be attempted before making this the api we use. then the api would simply be cc({ source, libraries })

would be cool to explore later letting this be statically analyzable with --compile, bundling library requirements alongside pre-compiled code.

---

a note about your benchmark

• -c:v copy tells ffmpeg to do nothing except memcpy the data streams
• mov and mp4 are the same format

would have to look at both files but your demo is possibly just re-encoding the metadata. this is good to show call overhead, but good video encoding take seconds or minutes, not milliseconds; i don't see ffmpeg via ffi over cli a notable use case.

the opinionated command i use for encoding mp4+H.264 doesn't really care about encode time, but more so file size and quality:

ffmpeg -i "$input" -c:v libx264 -preset:v slow -crf:v 24 -c:a aac -pix_fmt yuv420p -movflags +faststart "$output"

_{(-crf can be moved down, not below 18, for higher quality, moved up to not above 50 for lower quality)}

[190n]

so sorry, i hit the wrong button

[alextwothousand]

I’m curious, is there perhaps a method to specify compiler, and is there any possibility building as a shared library can be added?

[TheApproach]

does this use native types -- as in can I circumvent javascript's goofy floating point precision issues?