[BC-Breaking] Replace encode_image with save_image (#656)

Re-implement `encode_image` as a composition of `Muxer` and `Encoder` at
Python so that we can get rid of custom C++ code.

Author: mthrok

src/libspdl/core/CMakeLists.txt

@@ -26,7 +26,6 @@ set(srcs
   detail/ffmpeg/encoder.cpp
   detail/ffmpeg/decoder.cpp
   detail/ffmpeg/demuxer.cpp
-  detail/ffmpeg/encoding.cpp
   detail/ffmpeg/muxer.cpp
   detail/ffmpeg/filter_graph.cpp
   detail/ffmpeg/wrappers.cpp
@@ -42,7 +41,6 @@ set(srcs
   decoder.cpp
   demuxing.cpp
   codec.cpp
-  encoding.cpp
   muxer.cpp
   packets.cpp
   utils.cpp

src/libspdl/core/detail/ffmpeg/conversion.cpp

@@ -9,8 +9,8 @@
 #include <libspdl/core/conversion.h>
 
 #include "libspdl/core/detail/ffmpeg/compat.h"
-#include "libspdl/core/detail/ffmpeg/conversion.h"
 #include "libspdl/core/detail/ffmpeg/logging.h"
+#include "libspdl/core/detail/ffmpeg/wrappers.h"
 #include "libspdl/core/detail/logging.h"
 #include "libspdl/core/detail/tracing.h"
 
@@ -471,58 +471,8 @@ AVBufferRef* create_reference_buffer(uint8_t* data, int size) {
   return av_buffer_create(
       data, size, no_free, nullptr, AV_BUFFER_FLAG_READONLY);
 }
-
-void ref_interweaved(
-    AVFrame* frame,
-    void* data,
-    int num_channels,
-    int bit_depth = 1) {
-  auto* src = static_cast<uint8_t*>(data);
-  int linesize = frame->width * num_channels * bit_depth;
-  frame->data[0] = src;
-  frame->linesize[0] = linesize;
-  frame->buf[0] = create_reference_buffer(src, linesize * frame->height);
-}
-
-void ref_planar(AVFrame* frame, void* data, int num_channels) {
-  auto src = static_cast<uint8_t*>(data);
-  auto size = frame->width * frame->height;
-  for (int c = 0; c < num_channels; ++c) {
-    frame->data[c] = src;
-    frame->linesize[c] = frame->width;
-    frame->buf[c] = create_reference_buffer(src, size);
-    src += size;
-  }
-}
 } // namespace
 
-AVFramePtr reference_image_buffer(
-    AVPixelFormat fmt,
-    void* data,
-    size_t width,
-    size_t height) {
-  auto frame = get_video_frame(fmt, width, height, 0);
-  switch (fmt) {
-    case AV_PIX_FMT_RGB24:
-    case AV_PIX_FMT_BGR24:
-      ref_interweaved(frame.get(), data, 3);
-      break;
-    case AV_PIX_FMT_GRAY8:
-      ref_interweaved(frame.get(), data, 1);
-      break;
-    case AV_PIX_FMT_GRAY16:
-      ref_interweaved(frame.get(), data, 1, 2);
-      break;
-    case AV_PIX_FMT_YUV444P:
-      ref_planar(frame.get(), data, 3);
-      break;
-    default:
-      SPDL_FAIL(fmt::format(
-          "Unsupported source pixel format: {}", av_get_pix_fmt_name(fmt)));
-  }
-  return frame;
-}
-
 } // namespace detail
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -776,7 +726,8 @@ VideoFramesPtr create_reference_video_frame(
       validate_nhw(shape, stride);
       return create_reference_video_frame(
           fmt, data, shape, stride, time_base, pts, 1);
-    case AV_PIX_FMT_GRAY16:
+    case AV_PIX_FMT_GRAY16BE:
+    case AV_PIX_FMT_GRAY16LE:
       validate_nhw(shape, stride);
       CHECK_BITS(bits, 16);
       return create_reference_video_frame(

src/libspdl/core/detail/ffmpeg/conversion.h

@@ -282,108 +282,6 @@ const AVCodec* get_image_codec(
   return c;
 }
 
-namespace {
-bool is_pix_fmt_supported(
-    const AVPixelFormat fmt,
-    const AVPixelFormat* pix_fmts) {
-  if (!pix_fmts) {
-    return true;
-  }
-  while (*pix_fmts != AV_PIX_FMT_NONE) {
-    if (fmt == *pix_fmts) {
-      return true;
-    }
-    ++pix_fmts;
-  }
-  return false;
-}
-
-std::string to_str(const AVPixelFormat* pix_fmts) {
-  std::vector<std::string> ret;
-  while (*pix_fmts != AV_PIX_FMT_NONE) {
-    ret.emplace_back(av_get_pix_fmt_name(*pix_fmts));
-    ++pix_fmts;
-  }
-  return fmt::to_string(fmt::join(ret, ", "));
-}
-} // namespace
-
-AVPixelFormat get_enc_fmt(
-    AVPixelFormat src_fmt,
-    const std::optional<std::string>& encoder_format,
-    const AVCodec* codec) {
-  if (encoder_format) {
-    const auto& val = encoder_format.value();
-    auto fmt = av_get_pix_fmt(val.c_str());
-    if (!is_pix_fmt_supported(fmt, codec->pix_fmts)) {
-      SPDL_FAIL(fmt::format(
-          "Codec {} does not support {} format. Supported values are; {}",
-          codec->name,
-          val,
-          to_str(codec->pix_fmts)));
-    }
-    return fmt;
-  }
-  if (codec->pix_fmts) {
-    return codec->pix_fmts[0];
-  }
-  return src_fmt;
-}
-
-AVCodecContextPtr get_codec_ctx(const AVCodec* codec, int flags) {
-  auto ctx = AVCodecContextPtr{CHECK_AVALLOCATE(avcodec_alloc_context3(codec))};
-
-  if (flags & AVFMT_GLOBALHEADER) {
-    ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
-  }
-  return ctx;
-}
-
-void configure_video_codec_ctx(
-    AVCodecContextPtr& ctx,
-    AVPixelFormat format,
-    AVRational frame_rate,
-    int width,
-    int height,
-    const EncodeConfig& cfg) {
-  // TODO: Review other options and make them configurable?
-  // https://ffmpeg.org/doxygen/4.1/muxing_8c_source.html#l00147
-  //  - bit_rate_tolerance
-  //  - mb_decisions
-
-  ctx->pix_fmt = format;
-  ctx->width = width;
-  ctx->height = height;
-  ctx->time_base = av_inv_q(frame_rate);
-
-  // Set optional stuff
-  if (cfg.bit_rate > 0) {
-    ctx->bit_rate = cfg.bit_rate;
-  }
-  if (cfg.compression_level != -1) {
-    ctx->compression_level = cfg.compression_level;
-  }
-  if (cfg.gop_size != -1) {
-    ctx->gop_size = cfg.gop_size;
-  }
-  if (cfg.max_b_frames != -1) {
-    ctx->max_b_frames = cfg.max_b_frames;
-  }
-  if (cfg.qscale >= 0) {
-    ctx->flags |= AV_CODEC_FLAG_QSCALE;
-    ctx->global_quality = FF_QP2LAMBDA * cfg.qscale;
-  }
-}
-
-void configure_image_codec_ctx(
-    AVCodecContextPtr& ctx,
-    AVPixelFormat format,
-    int width,
-    int height,
-    const EncodeConfig& cfg) {
-  configure_video_codec_ctx(ctx, format, {1, 1}, width, height, cfg);
-}
-
 void open_codec_for_encode(
     AVCodecContext* codec_ctx,
     const std::optional<OptionDict>& encode_options) {
@@ -432,19 +330,6 @@ void open_codec_for_encode(
   check_empty(option);
 }
 
-AVStream* create_stream(
-    AVFormatContext* format_ctx,
-    AVCodecContext* codec_ctx) {
-  AVStream* stream = CHECK_AVALLOCATE(avformat_new_stream(format_ctx, nullptr));
-  // Note: time base may be adjusted when `calling avformat_write_header()`
-  // https://ffmpeg.org/doxygen/5.1/structAVStream.html#a9db755451f14e2bf590d4b85d82b32e6
-  stream->time_base = codec_ctx->time_base;
-  CHECK_AVERROR(
-      avcodec_parameters_from_context(stream->codecpar, codec_ctx),
-      "Failed to create a new stream.");
-  return stream;
-}
-
 void open_format(
     AVFormatContext* format_ctx,
     const std::optional<OptionDict>& options) {

src/libspdl/core/detail/ffmpeg/ctx_utils.cpp

@@ -47,39 +47,10 @@ AVFormatOutputContextPtr get_output_format_ctx(
     const std::string& url,
     const std::optional<std::string>& format = std::nullopt);
 
-const AVCodec* get_image_codec(
-    const std::optional<std::string>& encoder,
-    const AVOutputFormat* oformat,
-    const std::string& url);
-
-AVPixelFormat get_enc_fmt(
-    AVPixelFormat src_fmt,
-    const std::optional<std::string>& encoder_format,
-    const AVCodec* codec);
-
-AVCodecContextPtr get_codec_ctx(const AVCodec* codec, int flags);
-
-void configure_video_codec_ctx(
-    AVCodecContextPtr& ctx,
-    AVPixelFormat format,
-    AVRational frame_rate,
-    int width,
-    int height,
-    const EncodeConfig& cfg);
-
-void configure_image_codec_ctx(
-    AVCodecContextPtr& ctx,
-    AVPixelFormat format,
-    int width,
-    int height,
-    const EncodeConfig& cfg);
-
 void open_codec_for_encode(
     AVCodecContext* codec_ctx,
     const std::optional<OptionDict>& option);
 
-AVStream* create_stream(AVFormatContext* format_ctx, AVCodecContext* codec_ctx);
-
 void open_format(
     AVFormatContext* format_ctx,
     const std::optional<OptionDict>& option = std::nullopt);