path: root/Lua/src/lib/ffmpeg/avio.pas

(*
 * unbuffered io for ffmpeg system
 * copyright (c) 2001 Fabrice Bellard
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *)

(*
 * This is a part of Pascal porting of ffmpeg.
 * - Originally by Victor Zinetz for Delphi and Free Pascal on Windows.
 * - For Mac OS X, some modifications were made by The Creative CAT, denoted as CAT
 *   in the source codes.
 * - Changes and updates by the UltraStar Deluxe Team
 *)

(*
 * Conversion of libavformat/avio.h
 * unbuffered I/O operations
 * revision 16100, Sat Dec 13 13:39:13 2008 UTC
 * update Tue, Jun 10 01:00:00 2009 UTC
 *
 * @warning This file has to be considered an internal but installed
 * header, so it should not be directly included in your projects.
 *)

{
 * update to
 * Max. avformat version: 52.41.0, Sun Dec 6 20:15:00 2009 CET 
 * MiSchi
}

unit avio;

{$IFDEF FPC}
  {$MODE DELPHI }
  {$PACKENUM 4}    (* use 4-byte enums *)
  {$PACKRECORDS C} (* C/C++-compatible record packing *)
{$ELSE}
  {$MINENUMSIZE 4} (* use 4-byte enums *)
{$ENDIF}

{$I switches.inc}

interface

uses
  ctypes,
  avutil,
  avcodec,
  SysUtils,
  UConfig;

(* unbuffered I/O *)

const
  URL_RDONLY = 0;
  URL_WRONLY = 1;
  URL_RDWR   = 2;

 (**
  * Passing this as the "whence" parameter to a seek function causes it to
  * return the filesize without seeking anywhere. Supporting this is optional.
  * If it is not supported then the seek function will return <0.
  *)
  AVSEEK_SIZE = $10000;

type
  TURLInterruptCB = function (): cint; cdecl;

type
  PURLProtocol = ^TURLProtocol;

 (**
  * URL Context.
  * New fields can be added to the end with minor version bumps.
  * Removal, reordering and changes to existing fields require a major
  * version bump.
  * sizeof(URLContext) must not be used outside libav*.
  *)
  PURLContext = ^TURLContext;
  TURLContext = record
    {$IF LIBAVFORMAT_VERSION_MAJOR >= 53}
    av_class: {const} PAVClass; ///< information for av_log(). Set by url_open().
    {$IFEND}
    prot: PURLProtocol;
    flags: cint;
    is_streamed: cint;  (**< true if streamed (no seek possible), default = false *)
    max_packet_size: cint;  (**< if non zero, the stream is packetized with this max packet size *)
    priv_data: pointer;
    filename: PAnsiChar; (**< specified filename *)
  end;
  PPURLContext = ^PURLContext;

  PURLPollEntry = ^TURLPollEntry;
  TURLPollEntry = record
    handle: PURLContext;
    events: cint;
    revents: cint;
  end;

  TURLProtocol = record
    name: PAnsiChar;
    url_open: function (h: PURLContext; filename: {const} PAnsiChar; flags: cint): cint; cdecl;
    url_read: function (h: PURLContext; buf: PByteArray; size: cint): cint; cdecl;
    {$IF LIBAVFORMAT_VERSION >= 52034001} // 52.34.1
    url_read_complete: function (h: PURLContext; buf: PByteArray; size: cint): cint; cdecl;
    {$IFEND}
    url_write: function (h: PURLContext; buf: PByteArray; size: cint): cint; cdecl;
    url_seek: function (h: PURLContext; pos: cint64; whence: cint): cint64; cdecl;
    url_close: function (h: PURLContext): cint; cdecl;
    next: PURLProtocol;
    {$IF (LIBAVFORMAT_VERSION >= 52001000) and (LIBAVFORMAT_VERSION < 52004000)} // 52.1.0 .. 52.4.0
    url_read_play: function (h: PURLContext): cint; cdecl;
    url_read_pause: function (h: PURLContext): cint; cdecl;
    {$IFEND}
    {$IF LIBAVFORMAT_VERSION >= 52004000} // 52.4.0
    url_read_pause: function (h: PURLContext; pause: cint): cint; cdecl;
    {$IFEND}
    {$IF LIBAVFORMAT_VERSION >= 52001000} // 52.1.0
    url_read_seek: function (h: PURLContext; stream_index: cint;
                             timestamp: cint64; flags: cint): cint64; cdecl;
    {$IFEND}
  end;

 (**
  * Bytestream IO Context.
  * New fields can be added to the end with minor version bumps.
  * Removal, reordering and changes to existing fields require a major
  * version bump.
  * sizeof(ByteIOContext) must not be used outside libav*.
  *)
  PByteIOContext = ^TByteIOContext;
  TByteIOContext = record
    buffer: PByteArray;
    buffer_size: cint;
    buf_ptr: PByteArray;
    buf_end: PByteArray;
    opaque: pointer;
    read_packet: function (opaque: pointer; buf: PByteArray; buf_size: cint): cint; cdecl;
    write_packet: function (opaque: pointer; buf: PByteArray; buf_size: cint): cint; cdecl;
    seek: function (opaque: pointer; offset: cint64; whence: cint): cint64; cdecl;
    pos: cint64; (* position in the file of the current buffer *)
    must_flush: cint; (* true if the next seek should flush *)
    eof_reached: cint; (* true if eof reached *)
    write_flag: cint;  (* true if open for writing *)
    is_streamed: cint;
    max_packet_size: cint;
    checksum: culong;
    checksum_ptr: PByteArray;
    update_checksum: function (checksum: culong; buf: {const} PByteArray; size: cuint): culong; cdecl;
    error: cint;         ///< contains the error code or 0 if no error happened
    {$IF (LIBAVFORMAT_VERSION >= 52001000) and (LIBAVFORMAT_VERSION < 52004000)} // 52.1.0 .. 52.4.0
    read_play: function(opaque: Pointer): cint; cdecl;
    read_pause: function(opaque: Pointer): cint; cdecl;
    {$IFEND}
    {$IF LIBAVFORMAT_VERSION >= 52004000} // 52.4.0
    read_pause: function(opaque: Pointer; pause: cint): cint; cdecl;
    {$IFEND}
    {$IF LIBAVFORMAT_VERSION >= 52001000} // 52.1.0
    read_seek: function(opaque: Pointer; stream_index: cint;
                        timestamp: cint64; flags: cint): cint64; cdecl;
    {$IFEND}
  end;


{$IF LIBAVFORMAT_VERSION >= 52021000} // 52.21.0
function url_open_protocol(puc: PPURLContext; up: PURLProtocol;
                           filename: {const} PAnsiChar; flags: cint): cint;
  cdecl; external av__format;
{$IFEND}
function url_open(h: PPointer; filename: {const} PAnsiChar; flags: cint): cint;
  cdecl; external av__format;
function url_read (h: PURLContext; buf: PByteArray; size: cint): cint;
  cdecl; external av__format;
function url_write (h: PURLContext; buf: PByteArray; size: cint): cint;
  cdecl; external av__format;
function url_seek (h: PURLContext; pos: cint64; whence: cint): cint64;
  cdecl; external av__format;
function url_close (h: PURLContext): cint;
  cdecl; external av__format;
function url_exist(filename: {const} PAnsiChar): cint;
  cdecl; external av__format;
function url_filesize (h: PURLContext): cint64;
  cdecl; external av__format;
{
 * Return the file descriptor associated with this URL. For RTP, this
 * will return only the RTP file descriptor, not the RTCP file descriptor.
 * To get both, use rtp_get_file_handles().
 *
 * @return the file descriptor associated with this URL, or <0 on error.
}
(* not implemented *)
function url_get_file_handle(h: PURLContext): cint;
  cdecl; external av__format;

(**
 * Return the maximum packet size associated to packetized file
 * handle. If the file is not packetized (stream like HTTP or file on
 * disk), then 0 is returned.
 *
 * @param h file handle
 * @return maximum packet size in bytes
 *)
function url_get_max_packet_size(h: PURLContext): cint;
  cdecl; external av__format;
procedure url_get_filename(h: PURLContext; buf: PAnsiChar; buf_size: cint);
  cdecl; external av__format;

(**
 * The callback is called in blocking functions to test regulary if
 * asynchronous interruption is needed. AVERROR(EINTR) is returned
 * in this case by the interrupted function. 'NULL' means no interrupt
 * callback is given.
 *)
procedure url_set_interrupt_cb (interrupt_cb: TURLInterruptCB);
  cdecl; external av__format;

(* not implemented *)
function url_poll(poll_table: PURLPollEntry; n: cint; timeout: cint): cint;
  cdecl; external av__format;

{$IF LIBAVFORMAT_VERSION >= 52004000} // 52.4.0
(**
 * Pause and resume playing - only meaningful if using a network streaming
 * protocol (e.g. MMS).
 * @param pause 1 for pause, 0 for resume
 *)
function av_url_read_pause(h: PURLContext; pause: cint): cint;
  cdecl; external av__format;
{$IFEND}

{$IF LIBAVFORMAT_VERSION >= 52001000} // 52.1.0
(**
 * Seek to a given timestamp relative to some component stream.
 * Only meaningful if using a network streaming protocol (e.g. MMS.).
 * @param stream_index The stream index that the timestamp is relative to.
 *        If stream_index is (-1) the timestamp should be in AV_TIME_BASE
 *        units from the beginning of the presentation.
 *        If a stream_index >= 0 is used and the protocol does not support
 *        seeking based on component streams, the call will fail with ENOTSUP.
 * @param timestamp timestamp in AVStream.time_base units
 *        or if there is no stream specified then in AV_TIME_BASE units.
 * @param flags Optional combination of AVSEEK_FLAG_BACKWARD, AVSEEK_FLAG_BYTE
 *        and AVSEEK_FLAG_ANY. The protocol may silently ignore
 *        AVSEEK_FLAG_BACKWARD and AVSEEK_FLAG_ANY, but AVSEEK_FLAG_BYTE will
 *        fail with ENOTSUP if used and not supported.
 * @return >= 0 on success
 * @see AVInputFormat::read_seek
 *)
function av_url_read_seek(h: PURLContext; stream_index: cint;
                          timestamp: cint64; flags: cint): cint64;
  cdecl; external av__format;
{$IFEND}

(**
var
{$IF LIBAVFORMAT_VERSION_MAJOR < 53}
  first_protocol: PURLProtocol; external av__format;
{$IFEND}
  url_interrupt_cb: PURLInterruptCB; external av__format;
**)

{
* If protocol is NULL, returns the first registered protocol,
* if protocol is non-NULL, returns the next registered protocol after protocol,
* or NULL if protocol is the last one.
}
{$IF LIBAVFORMAT_VERSION >= 52002000} // 52.2.0
function av_protocol_next(p: PURLProtocol): PURLProtocol;
  cdecl; external av__format;
{$IFEND}

{$IF LIBAVFORMAT_VERSION <= 52028000} // 52.28.0
(**
 * @deprecated Use av_register_protocol() instead.
 *)
function register_protocol(protocol: PURLProtocol): cint;
  cdecl; external av__format;
(** Alias for register_protocol() *)
function av_register_protocol(protocol: PURLProtocol): cint;
  cdecl; external av__format name 'register_protocol';
{$ELSE}
function av_register_protocol(protocol: PURLProtocol): cint;
  cdecl; external av__format;
{$IFEND}

type
  TReadWriteFunc = function(opaque: Pointer; buf: PByteArray; buf_size: cint): cint; cdecl;
  TSeekFunc = function(opaque: Pointer; offset: cint64; whence: cint): cint64; cdecl;

function init_put_byte(s: PByteIOContext;
                buffer: PByteArray;
                buffer_size: cint; write_flag: cint;
                opaque: pointer;
                read_packet: TReadWriteFunc;
                write_packet: TReadWriteFunc;
                seek: TSeekFunc): cint;
  cdecl; external av__format;
{$IF LIBAVFORMAT_VERSION >= 52004000} // 52.4.0
function av_alloc_put_byte(
                  buffer: PByteArray;
                  buffer_size: cint;
                  write_flag: cint;
                  opaque: Pointer;
                  read_packet: TReadWriteFunc;
                  write_packet: TReadWriteFunc;
                  seek: TSeekFunc): PByteIOContext;
  cdecl; external av__format;
{$IFEND}

procedure put_byte(s: PByteIOContext; b: cint);
  cdecl; external av__format;
procedure put_buffer (s: PByteIOContext; buf: {const} PByteArray; size: cint);
  cdecl; external av__format;
procedure put_le64(s: PByteIOContext; val: cuint64);
  cdecl; external av__format;
procedure put_be64(s: PByteIOContext; val: cuint64);
  cdecl; external av__format;
procedure put_le32(s: PByteIOContext; val: cuint);
  cdecl; external av__format;
procedure put_be32(s: PByteIOContext; val: cuint);
  cdecl; external av__format;
procedure put_le24(s: PByteIOContext; val: cuint);
  cdecl; external av__format;
procedure put_be24(s: PByteIOContext; val: cuint);
  cdecl; external av__format;
procedure put_le16(s: PByteIOContext; val: cuint);
  cdecl; external av__format;
procedure put_be16(s: PByteIOContext; val: cuint);
  cdecl; external av__format;
procedure put_tag(s: PByteIOContext; tag: {const} PAnsiChar);
  cdecl; external av__format;

procedure put_strz(s: PByteIOContext; buf: {const} PAnsiChar);
  cdecl; external av__format;

(**
 * fseek() equivalent for ByteIOContext.
 * @return new position or AVERROR.
 *)
function url_fseek(s: PByteIOContext; offset: cint64; whence: cint): cint64;
  cdecl; external av__format;

(**
 * Skip given number of bytes forward.
 * @param offset number of bytes
 *)
procedure url_fskip(s: PByteIOContext; offset: cint64);
  cdecl; external av__format;

(**
 * ftell() equivalent for ByteIOContext.
 * @return position or AVERROR.
 *)
function url_ftell(s: PByteIOContext): cint64;
  cdecl; external av__format;

(**
 * Gets the filesize.
 * @return filesize or AVERROR
 *)
function url_fsize(s: PByteIOContext): cint64;
  cdecl; external av__format;

(**
 * feof() equivalent for ByteIOContext.
 * @return non zero if and only if end of file
 *)
function url_feof(s: PByteIOContext): cint;
  cdecl; external av__format;

function url_ferror(s: PByteIOContext): cint;
  cdecl; external av__format;

{$IF LIBAVFORMAT_VERSION >= 52004000} // 52.4.0
function av_url_read_fpause(h: PByteIOContext; pause: cint): cint;
  cdecl; external av__format;
{$IFEND}
{$IF LIBAVFORMAT_VERSION >= 52001000} // 52.1.0
function av_url_read_fseek(h: PByteIOContext; stream_index: cint;
                           timestamp: cint64; flags: cint): cint64;
  cdecl; external av__format;
{$IFEND}

const
  URL_EOF = -1;
(** @note return URL_EOF (-1) if EOF *)
function url_fgetc(s: PByteIOContext): cint;
  cdecl; external av__format;

(** @warning currently size is limited *)
function url_fprintf(s: PByteIOContext; fmt: {const} PAnsiChar; args: array of const): cint;
  cdecl; external av__format;

(** @note unlike fgets, the EOL character is not returned and a whole
   line is parsed. return NULL if first char read was EOF *)
function url_fgets(s: PByteIOContext; buf: PAnsiChar; buf_size: cint): PAnsiChar;
  cdecl; external av__format;

procedure put_flush_packet (s: PByteIOContext);
  cdecl; external av__format;
  

(**
 * Reads size bytes from ByteIOContext into buf.
 * @returns number of bytes read or AVERROR
 *)
function get_buffer(s: PByteIOContext; buf: PByteArray; size: cint): cint;
  cdecl; external av__format;

(**
 * Reads size bytes from ByteIOContext into buf.
 * This reads at most 1 packet. If that is not enough fewer bytes will be
 * returned.
 * @returns number of bytes read or AVERROR
 *)
function get_partial_buffer(s: PByteIOContext; buf: PByteArray; size: cint): cint;
  cdecl; external av__format;

(** @note return 0 if EOF, so you cannot use it if EOF handling is
   necessary *)
function get_byte(s: PByteIOContext): cint;
  cdecl; external av__format;
function get_le24(s: PByteIOContext): cuint;
  cdecl; external av__format;
function get_le32(s: PByteIOContext): cuint;
  cdecl; external av__format;
function get_le64(s: PByteIOContext): cuint64;
  cdecl; external av__format;
function get_le16(s: PByteIOContext): cuint;
  cdecl; external av__format;

function get_strz(s: PByteIOContext; buf: PAnsiChar; maxlen: cint): PAnsiChar;
  cdecl; external av__format;
function get_be16(s: PByteIOContext): cuint;
  cdecl; external av__format;
function get_be24(s: PByteIOContext): cuint;
  cdecl; external av__format;
function get_be32(s: PByteIOContext): cuint;
  cdecl; external av__format;
function get_be64(s: PByteIOContext): cuint64;
  cdecl; external av__format;

{$IF LIBAVFORMAT_VERSION >= 51017001} // 51.17.1
function ff_get_v(bc: PByteIOContext): cuint64;
  cdecl; external av__format;
{$IFEND}

function url_is_streamed(s: PByteIOContext): cint; {$IFDEF HasInline}inline;{$ENDIF}

(** @note when opened as read/write, the buffers are only used for
   writing *)
{$IF LIBAVFORMAT_VERSION >= 52000000} // 52.0.0
function url_fdopen (var s: PByteIOContext; h: PURLContext): cint;
{$ELSE}
function url_fdopen (s: PByteIOContext; h: PURLContext): cint;
{$IFEND}
  cdecl; external av__format;

(** @warning must be called before any I/O *)
function url_setbufsize (s: PByteIOContext; buf_size: cint): cint;
  cdecl; external av__format;

{$IF LIBAVFORMAT_VERSION_MAJOR < 53}
{$IF LIBAVFORMAT_VERSION >= 51015000} // 51.15.0
(** Reset the buffer for reading or writing.
 * @note Will drop any data currently in the buffer without transmitting it.
 * @param flags URL_RDONLY to set up the buffer for reading, or URL_WRONLY
 *        to set up the buffer for writing. *)
function url_resetbuf(s: PByteIOContext; flags: cint): cint;
  cdecl; external av__format;
{$IFEND}
{$IFEND}

(** @note when opened as read/write, the buffers are only used for
   writing *)
{$IF LIBAVFORMAT_VERSION >= 52000000} // 52.0.0
function url_fopen(var s: PByteIOContext; filename: {const} PAnsiChar; flags: cint): cint;
{$ELSE}
function url_fopen(s: PByteIOContext; filename: {const} PAnsiChar; flags: cint): cint;
{$IFEND}
  cdecl; external av__format;
function url_fclose(s: PByteIOContext): cint;
  cdecl; external av__format;
function url_fileno(s: PByteIOContext): PURLContext;
  cdecl; external av__format;

(**
 * Return the maximum packet size associated to packetized buffered file
 * handle. If the file is not packetized (stream like http or file on
 * disk), then 0 is returned.
 *
 * @param s buffered file handle
 * @return maximum packet size in bytes
 *)
function url_fget_max_packet_size (s: PByteIOContext): cint;
  cdecl; external av__format;

{$IF LIBAVFORMAT_VERSION >= 52000000} // 52.0.0
function url_open_buf(var s: PByteIOContext; buf: PAnsiChar; buf_size: cint; flags: cint): cint;
{$ELSE}
function url_open_buf(s: PByteIOContext; buf: PAnsiChar; buf_size: cint; flags: cint): cint;
{$IFEND}
  cdecl; external av__format;

(** return the written or read size *)
function url_close_buf(s: PByteIOContext): cint;
  cdecl; external av__format;

(**
 * Open a write only memory stream.
 *
 * @param s new IO context
 * @return zero if no error.
 *)
{$IF LIBAVFORMAT_VERSION >= 52000000} // 52.0.0
function url_open_dyn_buf(var s: PByteIOContext): cint;
{$ELSE}
function url_open_dyn_buf(s: PByteIOContext): cint;
{$IFEND}
  cdecl; external av__format;

(**
 * Open a write only packetized memory stream with a maximum packet
 * size of 'max_packet_size'.  The stream is stored in a memory buffer
 * with a big endian 4 byte header giving the packet size in bytes.
 *
 * @param s new IO context
 * @param max_packet_size maximum packet size (must be > 0)
 * @return zero if no error.
 *)
{$IF LIBAVFORMAT_VERSION >= 52000000} // 52.0.0
function url_open_dyn_packet_buf(var s: PByteIOContext; max_packet_size: cint): cint;
{$ELSE}
function url_open_dyn_packet_buf(s: PByteIOContext; max_packet_size: cint): cint;
{$IFEND}
  cdecl; external av__format;

(**
 * Return the written size and a pointer to the buffer. The buffer
 *  must be freed with av_free().
 * @param s IO context
 * @param pbuffer pointer to a byte buffer
 * @return the length of the byte buffer
 *)
function url_close_dyn_buf(s: PByteIOContext; pbuffer:PPointer): cint;
  cdecl; external av__format;

{$IF LIBAVFORMAT_VERSION >= 51017001} // 51.17.1
function ff_crc04C11DB7_update(checksum: culong; buf: {const} PByteArray;
                               len: cuint): culong;
  cdecl; external av__format;
{$IFEND}
function get_checksum(s: PByteIOContext): culong;
  cdecl; external av__format;
procedure init_gsum(s: PByteIOContext;
                        update_checksum: pointer;
                        checksum: culong);
  cdecl; external av__format;

(* udp.c *)
function udp_set_remote_url(h: PURLContext; uri: {const} PAnsiChar): cint;
  cdecl; external av__format;
function udp_get_local_port(h: PURLContext): cint;
  cdecl; external av__format;
{$IF LIBAVFORMAT_VERSION_MAJOR <= 52}
function udp_get_file_handle(h: PURLContext): cint;
  cdecl; external av__format;
{$IFEND}
  
implementation

function url_is_streamed(s: PByteIOContext): cint;
begin
  Result := s^.is_streamed;
end;

end.