libextractor

mediaffmpeg.c (7549B)

---

 /*
      This file is part of libextractor.
      Copyright (C) 2026 Vidyut Samanta and Christian Grothoff
 
      libextractor is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
      by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      libextractor is distributed in the hope that it will be useful, but
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      General Public License for more details.
 
      You should have received a copy of the GNU General Public License
      along with libextractor; see the file COPYING.  If not, write to the
      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      Boston, MA 02110-1301, USA.
  */
 /**
  * @file plugins/mediaffmpeg.c
  * @brief plumbing between an extraction context and FFmpeg's demuxer
  * @author Christian Grothoff
  */
 #include "platform.h"
 #include "mediaffmpeg.h"
 
 
 /**
  * Implementation of AVIOContext's read callback.
  *
  * @param opaque our `struct EXTRACTOR_FFmpegIO`
  * @param buf where to write the data
  * @param buf_size number of bytes to read
  * @return number of bytes read, AVERROR_EOF at the end of the file
  */
 static int
 read_packet (void *opaque,
              uint8_t *buf,
              int buf_size)
 {
   struct EXTRACTOR_FFmpegIO *io = opaque;
   void *data;
   ssize_t ret;
 
   ret = io->ec->read (io->ec->cls,
                       &data,
                       buf_size);
   if (ret <= 0)
     return AVERROR_EOF;
   /* the buffer handed back by read() is only valid until the next call */
   memcpy (buf,
           data,
           ret);
   return (int) ret;
 }
 
 
 /**
  * Implementation of AVIOContext's seek callback.
  *
  * @param opaque our `struct EXTRACTOR_FFmpegIO`
  * @param offset position to seek to
  * @param whence SEEK_SET, SEEK_CUR, SEEK_END or AVSEEK_SIZE
  * @return new position, or a negative error code
  */
 static int64_t
 seek_packet (void *opaque,
              int64_t offset,
              int whence)
 {
   struct EXTRACTOR_FFmpegIO *io = opaque;
   uint64_t size;
 
   if (AVSEEK_SIZE == (whence & ~AVSEEK_FORCE))
   {
     size = io->ec->get_size (io->ec->cls);
     if (UINT64_MAX == size)
       return AVERROR (ESPIPE);
     return (int64_t) size;
   }
   return io->ec->seek (io->ec->cls,
                        offset,
                        whence & ~AVSEEK_FORCE);
 }
 
 
 /**
  * Implementation of AVIOInterruptCB; lets us get out of a decoder that is
  * taking too long instead of being killed by the parent process.
  *
  * @param opaque our `struct EXTRACTOR_FFmpegIO`
  * @return 1 if FFmpeg should abort
  */
 static int
 interrupt_callback (void *opaque)
 {
   struct EXTRACTOR_FFmpegIO *io = opaque;
 
   return EXTRACTOR_media_deadline_expired_ (&io->deadline);
 }
 
 
 /**
  * Swallow the diagnostics FFmpeg would otherwise write to stderr.
  *
  * @param ptr unused
  * @param level unused
  * @param fmt unused
  * @param vl unused
  */
 static void
 log_callback (void *ptr,
               int level,
               const char *fmt,
               va_list vl)
 {
   (void) ptr;
   (void) level;
   (void) fmt;
   (void) vl;
 }
 
 
 void
 EXTRACTOR_ffmpeg_silence_ ()
 {
   /* When something goes wrong in here, FFmpeg's log is the only thing
      that will tell you what; keep it available for debugging, since in
      the normal (out-of-process) case stderr is closed anyway. */
   if (NULL != getenv ("LIBEXTRACTOR_DEBUG"))
     return;
   av_log_set_callback (&log_callback);
 }
 
 
 int
 EXTRACTOR_ffmpeg_open_ (struct EXTRACTOR_FFmpegIO *io)
 {
   uint8_t *buffer;
 
   io->fmt = NULL;
   io->avio = NULL;
   if (NULL == (buffer = av_malloc (EXTRACTOR_FFMPEG_AVIO_BUFFER)))
     return -1;
   if (NULL == (io->avio = avio_alloc_context (buffer,
                                               EXTRACTOR_FFMPEG_AVIO_BUFFER,
                                               0,
                                               io,
                                               &read_packet,
                                               NULL,
                                               &seek_packet)))
   {
     av_free (buffer);
     return -1;
   }
   if (NULL == (io->fmt = avformat_alloc_context ()))
   {
     EXTRACTOR_ffmpeg_close_ (io);
     return -1;
   }
   io->fmt->pb = io->avio;
   io->fmt->flags |= AVFMT_FLAG_CUSTOM_IO;
   io->fmt->probesize = EXTRACTOR_FFMPEG_PROBE_SIZE;
   io->fmt->max_analyze_duration = EXTRACTOR_FFMPEG_MAX_ANALYZE;
   io->fmt->interrupt_callback.callback = &interrupt_callback;
   io->fmt->interrupt_callback.opaque = io;
   if (0 != avformat_open_input (&io->fmt,
                                 NULL,
                                 NULL,
                                 NULL))
   {
     /* avformat_open_input() freed the context for us */
     io->fmt = NULL;
     EXTRACTOR_ffmpeg_close_ (io);
     return -1;
   }
   if (0 > avformat_find_stream_info (io->fmt,
                                      NULL))
   {
     EXTRACTOR_ffmpeg_close_ (io);
     return -1;
   }
   return 0;
 }
 
 
 void
 EXTRACTOR_ffmpeg_close_ (struct EXTRACTOR_FFmpegIO *io)
 {
   if (NULL != io->fmt)
     avformat_close_input (&io->fmt);
   if (NULL != io->avio)
   {
     /* we passed AVFMT_FLAG_CUSTOM_IO, so this is still ours to free; note
        that avio may have replaced the buffer we originally handed it */
     av_free (io->avio->buffer);
     avio_context_free (&io->avio);
   }
 }
 
 
 int
 EXTRACTOR_ffmpeg_open_stream_ (struct EXTRACTOR_FFmpegIO *io,
                                enum AVMediaType type,
                                AVCodecContext **ctx)
 {
   const AVCodec *codec;
   AVCodecContext *cc;
   int stream;
 
   *ctx = NULL;
   stream = av_find_best_stream (io->fmt,
                                 type,
                                 -1,
                                 -1,
                                 &codec,
                                 0);
   if ( (0 > stream) ||
        (NULL == codec) )
     return -1;
   if (NULL == (cc = avcodec_alloc_context3 (codec)))
     return -1;
   if (0 > avcodec_parameters_to_context (cc,
                                          io->fmt->streams[stream]->codecpar))
   {
     avcodec_free_context (&cc);
     return -1;
   }
   /* one thread: we are in a forked child that is expected to talk to its
      parent regularly, and there is nothing here worth parallelizing */
   cc->thread_count = 1;
   if (0 != avcodec_open2 (cc, codec, NULL))
   {
     avcodec_free_context (&cc);
     return -1;
   }
   *ctx = cc;
   return stream;
 }
 
 
 double
 EXTRACTOR_ffmpeg_seek_ (struct EXTRACTOR_FFmpegIO *io,
                         int stream,
                         AVCodecContext *ctx,
                         unsigned int offset)
 {
   double duration;
   double target;
   int64_t ts;
 
   duration = (AV_NOPTS_VALUE == io->fmt->duration)
              ? -1.0
              : ((double) io->fmt->duration) / AV_TIME_BASE;
   target = offset;
   if ( (duration > 0.0) &&
        (target > duration / 3.0) )
     target = duration / 3.0;
   if ( (target <= 1.0) ||
        (duration <= 0.0) )
     return (target <= 1.0) ? 0.0 : target;
   ts = av_rescale_q ((int64_t) (target * AV_TIME_BASE),
                      AV_TIME_BASE_Q,
                      io->fmt->streams[stream]->time_base);
   if (0 > av_seek_frame (io->fmt,
                          stream,
                          ts,
                          AVSEEK_FLAG_BACKWARD))
     return 0.0;   /* seeking failed; caller decodes from wherever we are */
   avcodec_flush_buffers (ctx);
   return target;
 }
 
 
 /* end of mediaffmpeg.c */