working on the libavutil files.

git-svn-id: svn://svn.code.sf.net/p/ultrastardx/svn/trunk@3048 b956fd51-792f-4845-bead-9b4dfca2ff2c

8 files changed, 247 insertions, 66 deletions

diff --git a/src/lib/ffmpeg-2.1/libavutil/cpu.pas b/src/lib/ffmpeg-2.1/libavutil/cpu.pas
index 635b8928..4cb468a8 100644
--- a/src/lib/ffmpeg-2.1/libavutil/cpu.pas
+++ b/src/lib/ffmpeg-2.1/libavutil/cpu.pas
@@ -19,7 +19,7 @@
  * - Changes and updates by the UltraStar Deluxe Team
  *
  * Conversion of libavutil/cpu.h
- * avutil version 52.38.100
+ * avutil version 52.48.100 - 52.48.101
  *
  *)
 
@@ -35,9 +35,11 @@ const
   AV_CPU_FLAG_SSE           = $0008;     ///< SSE functions
   AV_CPU_FLAG_SSE2          = $0010;     ///< PIV SSE2 functions
   AV_CPU_FLAG_SSE2SLOW      = $40000000; ///< SSE2 supported, but usually not faster
+                                         ///< than regular MMX/SSE (e.g. Core1)
   AV_CPU_FLAG_3DNOWEXT      = $0020;     ///< AMD 3DNowExt
   AV_CPU_FLAG_SSE3          = $0040;     ///< Prescott SSE3 functions
   AV_CPU_FLAG_SSE3SLOW      = $20000000; ///< SSE3 supported, but usually not faster
+                                         ///< than regular MMX/SSE (e.g. Core1)
   AV_CPU_FLAG_SSSE3         = $0080;     ///< Conroe SSSE3 functions
   AV_CPU_FLAG_ATOM          = $10000000; ///< Atom processor, some SSSE3 instructions are slower
   AV_CPU_FLAG_SSE4          = $0100;     ///< Penryn SSE4.1 functions
@@ -48,6 +50,8 @@ const
  
   AV_CPU_FLAG_CMOV          = $1001000;  ///< supports cmov instruction
   
+  AV_CPU_FLAG_AVX2          = $8000;     ///< AVX2 functions: requires OS support even if YMM registers aren't used
+
   AV_CPU_FLAG_ALTIVEC       = $0001;     ///< standard
 
   AV_CPU_FLAG_ARMV5TE       = (1 << 0);
@@ -108,11 +112,3 @@ function av_parse_cpu_caps(flags: Pcuint; s: {const} PAnsiChar): cint;
  *)
 function av_cpu_count(): cint;
   cdecl; external av__util;
-
-(* The following CPU-specific functions shall not be called directly. *)
-function ff_get_cpu_flags_arm(): cint;
-  cdecl; external av__util;
-function ff_get_cpu_flags_ppc(): cint;
-  cdecl; external av__util;
-function ff_get_cpu_flags_x86(): cint;
-  cdecl; external av__util;
diff --git a/src/lib/ffmpeg-2.1/libavutil/error.pas b/src/lib/ffmpeg-2.1/libavutil/error.pas
index 4406c2cd..5ddd2a74 100644
--- a/src/lib/ffmpeg-2.1/libavutil/error.pas
+++ b/src/lib/ffmpeg-2.1/libavutil/error.pas
@@ -31,7 +31,7 @@
 (**
  * @addtogroup lavu_error
  *
- * @{
+ * @
  *)
 
 {* error handling *}
diff --git a/src/lib/ffmpeg-2.1/libavutil/log.pas b/src/lib/ffmpeg-2.1/libavutil/log.pas
index 73057a36..ebbc2f3a 100644
--- a/src/lib/ffmpeg-2.1/libavutil/log.pas
+++ b/src/lib/ffmpeg-2.1/libavutil/log.pas
@@ -131,6 +131,9 @@ type
 end;
 
 const
+(**
+ * Print no output.
+ *)
   AV_LOG_QUIET   = -8;
 
 (**
@@ -157,8 +160,15 @@ const
  *)
   AV_LOG_WARNING = 24;
 
+(**
+ * Standard information.
+ *)
   AV_LOG_INFO    = 32;
-  AV_LOG_VERBOSE = 40;
+
+(**
+ * Detailed information.
+ *)
+	AV_LOG_VERBOSE = 40;
 
 (**
  * Stuff which is only useful for libav* developers.
@@ -170,18 +180,17 @@ const
 (**
  * Send the specified message to the log if the level is less than or equal
  * to the current av_log_level. By default, all logging messages are sent to
- * stderr. This behavior can be altered by setting a different av_vlog callback
+ * stderr. This behavior can be altered by setting a different logging callback
  * function.
+ * @see av_log_set_callback
  *
  * @param avcl A pointer to an arbitrary struct of which the first field is a
- * pointer to an AVClass struct.
- * @param level The importance level of the message, lower values signifying
- * higher importance.
+ *        pointer to an AVClass struct.
+ * @param level The importance level of the message expressed using a @ref
+ *        lavu_log_constants "Logging Constant".
  * @param fmt The format string (printf-compatible) that specifies how
- * subsequent arguments are converted to output.
- * @see av_vlog
+ *        subsequent arguments are converted to output.
  *)
-
 {** to be translated if needed
 void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4);
 **}
@@ -189,19 +198,83 @@ void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4);
 type
   va_list = pointer;
 
-procedure av_vlog(avcl: pointer; level: cint; fmt: {const} PAnsiChar; dummy: va_list);
+(**
+ * Send the specified message to the log if the level is less than or equal
+ * to the current av_log_level. By default, all logging messages are sent to
+ * stderr. This behavior can be altered by setting a different logging callback
+ * function.
+ * @see av_log_set_callback
+ *
+ * @param avcl A pointer to an arbitrary struct of which the first field is a
+ *        pointer to an AVClass struct.
+ * @param level The importance level of the message expressed using a @ref
+ *        lavu_log_constants "Logging Constant".
+ * @param fmt The format string (printf-compatible) that specifies how
+ *        subsequent arguments are converted to output.
+ * @param vl The arguments referenced by the format string.
+ *)
+procedure av_vlog(avcl: pointer; level: cint; fmt: {const} PAnsiChar; vl: va_list);
   cdecl; external av__util;
+
+(**
+ * Get the current log level
+ *
+ * @see lavu_log_constants
+ *
+ * @return Current log level
+ *)
 function av_log_get_level(): cint;
   cdecl; external av__util;
+
+(**
+ * Set the log level
+ *
+ * @see lavu_log_constants
+ *
+ * @param level Logging level
+ *)
 procedure av_log_set_level(level: cint);
   cdecl; external av__util;
 
+(**
+ * Set the logging callback
+ *
+ * @note The callback must be thread safe, even if the application does not use
+ *       threads itself as some codecs are multithreaded.
+ *
+ * @see av_log_default_callback
+ *
+ * @param callback A logging function with a compatible signature.
+ *)
+{** to be translated if needed
+void av_log_set_callback(void (*callback)(void*, int, const char*, va_list));
+**}
+
+(**
+ * Default logging callback
+ *
+ * It prints the message to stderr, optionally colorizing it.
+ *
+ * @param avcl A pointer to an arbitrary struct of which the first field is a
+ *        pointer to an AVClass struct.
+ * @param level The importance level of the message expressed using a @ref
+ *        lavu_log_constants "Logging Constant".
+ * @param fmt The format string (printf-compatible) that specifies how
+ *        subsequent arguments are converted to output.
+ * @param ap The arguments referenced by the format string.
+ *)
 {** to be translated if needed
-void av_log_set_callback(void (*)(void*, int, const char*, va_list));
 void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl);
 **}
 
-function av_default_item_name (ctx: pointer): PAnsiChar;
+(**
+ * Return the context name
+ *
+ * @param  ctx The AVClass context
+ *
+ * @return The AVClass class_name
+ *)
+function av_default_item_name(ctx: pointer): PAnsiChar;
   cdecl; external av__util;
 function av_default_get_category(ptr: pointer): TAVClassCategory;
   cdecl; external av__util;
diff --git a/src/lib/ffmpeg-2.1/libavutil/mathematics.pas b/src/lib/ffmpeg-2.1/libavutil/mathematics.pas
index 60c9e16c..9964b6fd 100644
--- a/src/lib/ffmpeg-2.1/libavutil/mathematics.pas
+++ b/src/lib/ffmpeg-2.1/libavutil/mathematics.pas
@@ -40,7 +40,7 @@ const
 
 (**
  * @addtogroup lavu_math
- * @{
+ * @
  *)
 
 type
diff --git a/src/lib/ffmpeg-2.1/libavutil/mem.pas b/src/lib/ffmpeg-2.1/libavutil/mem.pas
index 17c3461c..d7e0ca90 100644
--- a/src/lib/ffmpeg-2.1/libavutil/mem.pas
+++ b/src/lib/ffmpeg-2.1/libavutil/mem.pas
@@ -42,8 +42,7 @@ function av_malloc(size: size_t): pointer;
   cdecl; external av__util; {av_malloc_attrib av_alloc_size(1)}
 
 (**
- * Helper function to allocate a block of size * nmemb bytes with
- * using av_malloc()
+ * Allocate a block of size * nmemb bytes with av_malloc().
  * @param nmemb Number of elements
  * @param size Size of the single element
  * @return Pointer to the allocated block, NULL if the block cannot
@@ -55,14 +54,20 @@ function av_malloc_array(nmemb: size_t; size: size_t): pointer; {$IFDEF HasInlin
 
 (**
  * Allocate or reallocate a block of memory.
- * If ptr is NULL and size > 0, allocate a new block. If 
+ * If ptr is NULL and size > 0, allocate a new block. If
  * size is zero, free the memory block pointed to by ptr.
  * @param ptr Pointer to a memory block already allocated with
- * av_malloc(z)() or av_realloc() or NULL.
- * @param size Size in bytes for the memory block to be allocated or
+ * av_realloc() or NULL.
+ * @param size Size in bytes of the memory block to be allocated or
  * reallocated.
- * @return Pointer to a newly reallocated block or NULL if the block
- * cannot be allocated or the function is used to free the memory block.
+ * @return Pointer to a newly-reallocated block or NULL if the block
+ * cannot be reallocated or the function is used to free the memory block.
+ * @warning Pointers originating from the av_malloc() family of functions must
+ *          not be passed to av_realloc(). The former can be implemented using
+ *          memalign() (or other functions), and there is no guarantee that
+ *          pointers from such functions can be passed to realloc() at all.
+ *          The situation is undefined according to POSIX and may crash with
+ *          some libc implementations.
  * @see av_fast_realloc()
  *)
 function av_realloc(ptr: pointer; size: size_t): pointer;
@@ -80,29 +85,61 @@ function av_realloc_f(ptr: pointer; nelem: size_t; elsize: size_t): pointer;
   cdecl; external av__util;
 
 (**
+ * Allocate or reallocate a block of memory.
+ * If *ptr is NULL and size > 0, allocate a new block. If
+ * size is zero, free the memory block pointed to by ptr.
+ * @param   ptr Pointer to a pointer to a memory block already allocated
+ *          with av_realloc(), or pointer to a pointer to NULL.
+ *          The pointer is updated on success, or freed on failure.
+ * @param   size Size in bytes for the memory block to be allocated or
+ *          reallocated
+ * @return  Zero on success, an AVERROR error code on failure.
+ * @warning Pointers originating from the av_malloc() family of functions must
+ *          not be passed to av_reallocp(). The former can be implemented using
+ *          memalign() (or other functions), and there is no guarantee that
+ *          pointers from such functions can be passed to realloc() at all.
+ *          The situation is undefined according to POSIX and may crash with
+ *          some libc implementations.
+ *)
+function av_reallocp(ptr: pointer; elsize: size_t): cint;
+  cdecl; external av__util;
+
+(**
  * Allocate or reallocate an array.
  * If ptr is NULL and nmemb > 0, allocate a new block. If
  * nmemb is zero, free the memory block pointed to by ptr.
  * @param ptr Pointer to a memory block already allocated with
- * av_malloc(z)() or av_realloc() or NULL.
+ * av_realloc() or NULL.
  * @param nmemb Number of elements
  * @param size Size of the single element
- * @return Pointer to a newly reallocated block or NULL if the block
+ * @return Pointer to a newly-reallocated block or NULL if the block
  * cannot be reallocated or the function is used to free the memory block.
+ * @warning Pointers originating from the av_malloc() family of functions must
+ *          not be passed to av_realloc(). The former can be implemented using
+ *          memalign() (or other functions), and there is no guarantee that
+ *          pointers from such functions can be passed to realloc() at all.
+ *          The situation is undefined according to POSIX and may crash with
+ *          some libc implementations.
  *)
 function av_realloc_array(ptr: pointer; nmemb, size: size_t): pointer; {av_alloc_size(2, 3)}
   cdecl; external av__util;
 
 (**
- * Allocate or reallocate an array.
+ * Allocate or reallocate an array through a pointer to a pointer.
  * If *ptr is NULL and nmemb > 0, allocate a new block. If
  * nmemb is zero, free the memory block pointed to by ptr.
  * @param ptr Pointer to a pointer to a memory block already allocated
- * with av_malloc(z)() or av_realloc(), or pointer to a pointer to NULL.
+ * with av_realloc(), or pointer to a pointer to NULL.
  * The pointer is updated on success, or freed on failure.
  * @param nmemb Number of elements
  * @param size Size of the single element
  * @return Zero on success, an AVERROR error code on failure.
+ * @warning Pointers originating from the av_malloc() family of functions must
+ *          not be passed to av_realloc(). The former can be implemented using
+ *          memalign() (or other functions), and there is no guarantee that
+ *          pointers from such functions can be passed to realloc() at all.
+ *          The situation is undefined according to POSIX and may crash with
+ *          some libc implementations.
  *)
 function av_reallocp_array(ptr: pointer; nmemb, size: size_t): cint; {av_alloc_size(2, 3)}
   cdecl; external av__util;
@@ -143,8 +180,7 @@ function av_calloc(nmemb: size_t; size: size_t): pointer;
   cdecl; external av__util; {av_malloc_attrib}
 
 (**
- * Helper function to allocate a block of size * nmemb bytes with
- * using av_mallocz()
+ * Allocate a block of size * nmemb bytes with av_mallocz().
  * @param nmemb Number of elements
  * @param size Size of the single element
  * @return Pointer to the allocated block, NULL if the block cannot
@@ -158,7 +194,7 @@ function av_mallocz_array(nmemb: size_t; size: size_t): pointer; {$IFDEF HasInli
 (**
  * Duplicate the string s.
  * @param s string to be duplicated.
- * @return Pointer to a newly allocated string containing a
+ * @return Pointer to a newly-allocated string containing a
  * copy of s or NULL if the string cannot be allocated.
  *)
 function av_strdup({const} s: PAnsiChar): PAnsiChar;
@@ -254,7 +290,7 @@ procedure av_max_alloc(max: size_t);
   cdecl; external av__util;
 
 (**
- * @brief deliberately overlapping memcpy implementation
+ * deliberately overlapping memcpy implementation
  * @param dst destination buffer
  * @param back how many bytes back we start (the initial size of the overlapping window), must be > 0
  * @param cnt number of bytes to copy, must be >= 0
diff --git a/src/lib/ffmpeg-2.1/libavutil/opt.pas b/src/lib/ffmpeg-2.1/libavutil/opt.pas
index c2fa6798..7abf0a2a 100644
--- a/src/lib/ffmpeg-2.1/libavutil/opt.pas
+++ b/src/lib/ffmpeg-2.1/libavutil/opt.pas
@@ -49,12 +49,13 @@ type
     AV_OPT_TYPE_RATIONAL,
     AV_OPT_TYPE_BINARY,  ///< offset must point to a pointer immediately followed by an int for the length
     AV_OPT_TYPE_CONST = 128,
-    AV_OPT_TYPE_COLOR      = $434F4C52,  ///< MKBETAG('C','O','L','R'),
-    AV_OPT_TYPE_DURATION   = $44555220,  ///< MKBETAG('D','U','R',' '),
-    AV_OPT_TYPE_PIXEL_FMT  = $50464D54, ///< MKBETAG('P','F','M','T')
-    AV_OPT_TYPE_SAMPLE_FMT = $53464D54, ///< MKBETAG('S','F','M','T')
-    AV_OPT_TYPE_IMAGE_SIZE = $53495A45,  ///< MKBETAG('S','I','Z','E'), offset must point to two consecutive integers
-    AV_OPT_TYPE_VIDEO_RATE = $56524154  ///< MKBETAG('V','R','A','T'), offset must point to AVRational
+		AV_OPT_TYPE_CHANNEL_LAYOUT = $43484C41,  ///< MKBETAG('C','H','L','A'),
+    AV_OPT_TYPE_COLOR          = $434F4C52,  ///< MKBETAG('C','O','L','R'),
+    AV_OPT_TYPE_DURATION       = $44555220,  ///< MKBETAG('D','U','R',' '),
+    AV_OPT_TYPE_PIXEL_FMT      = $50464D54,  ///< MKBETAG('P','F','M','T')
+    AV_OPT_TYPE_SAMPLE_FMT     = $53464D54,  ///< MKBETAG('S','F','M','T')
+    AV_OPT_TYPE_IMAGE_SIZE     = $53495A45,  ///< MKBETAG('S','I','Z','E'), offset must point to two consecutive integers
+    AV_OPT_TYPE_VIDEO_RATE     = $56524154   ///< MKBETAG('V','R','A','T'), offset must point to TAVRational
 {$ENDIF}
   );
 
@@ -139,7 +140,7 @@ type
 (**
  * Look for an option in obj. Look only for the options which
  * have the flags set as specified in mask and flags (that is,
- * for which it is the case that opt->flags & mask == flags).
+ * for which it is the case that (opt->flags & mask) == flags).
  *
  * @param[in] obj a pointer to a struct whose first element is a
  * pointer to an AVClass
@@ -349,7 +350,7 @@ const
 
 (**
  * @defgroup opt_eval_funcs Evaluating option strings
- * @{
+ * @
  * This group of functions can be used to evaluate option strings
  * and get numbers out of them. They do the same thing as av_opt_set(),
  * except the result is written into the caller-supplied pointer.
@@ -362,16 +363,22 @@ const
  * @return 0 on success, a negative number on failure.
  *)
 function av_opt_eval_flags (obj: pointer; o: {const} PAVOption; val: {const} PAnsiChar; flags_out:  Pcint):       cint;
+  cdecl; external av__util;
 function av_opt_eval_int   (obj: pointer; o: {const} PAVOption; val: {const} PAnsiChar; int_out:    Pcint):       cint;
+  cdecl; external av__util;
 function av_opt_eval_int64 (obj: pointer; o: {const} PAVOption; val: {const} PAnsiChar; int64_out:  Pcint64):     cint;
+  cdecl; external av__util;
 function av_opt_eval_float (obj: pointer; o: {const} PAVOption; val: {const} PAnsiChar; float_out:  Pcfloat):     cint;
+  cdecl; external av__util;
 function av_opt_eval_double(obj: pointer; o: {const} PAVOption; val: {const} PAnsiChar; double_out: Pcdouble):    cint;
+  cdecl; external av__util;
 function av_opt_eval_q     (obj: pointer; o: {const} PAVOption; val: {const} PAnsiChar; q_out:      PAVRational): cint;
+  cdecl; external av__util;
 (**
- * @}
+ * @
  *)
 
- const
+const
   AV_OPT_SEARCH_CHILDREN = 0001; (**< Search in possible children of the
                                       given object first.*)
 (**
@@ -463,7 +470,7 @@ function av_opt_child_class_next(parent: {const} PAVClass; prev: {const} PAVClas
 
 (**
  * @defgroup opt_set_funcs Option setting functions
- * @{
+ * @
  * Those functions set the field of obj with the given name to value.
  *
  * @param[in] obj A struct whose first element is a pointer to an AVClass.
@@ -505,6 +512,8 @@ function av_opt_set_sample_fmt(obj: pointer; name: {const} PAnsiChar; fmt: TAVPi
   cdecl; external av__util;
 function av_opt_set_video_rate(obj: pointer; name: {const} PAnsiChar; val: TAVRational;       search_flags: cint): cint;
   cdecl; external av__util;
+function av_opt_set_channel_layout(obj: pointer; name: {const} PAnsiChar; ch_layout: cint64;  search_flags: cint): cint;
+  cdecl; external av__util;
 
 (**
  * Set a binary option to an integer list.
@@ -524,12 +533,12 @@ function av_opt_set_video_rate(obj: pointer; name: {const} PAnsiChar; val: TAVRa
                     av_int_list_length(val, term) * sizeof(*(val)), flags))
 }
 (**
- * @}
+ * @
  *)
 
 (**
  * @defgroup opt_get_funcs Option getting functions
- * @{
+ * @
  * Those functions get a value of the option with the given name from an object.
  *
  * @param[in] obj a struct whose first element is a pointer to an AVClass.
@@ -537,10 +546,10 @@ function av_opt_set_video_rate(obj: pointer; name: {const} PAnsiChar; val: TAVRa
  * @param[in] search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
  * is passed here, then the option may be found in a child of obj.
  * @param[out] out_val value of the option will be written here
- * @return 0 on success, a negative error code otherwise
+ * @return >=0 on success, a negative error code otherwise
  *)
 (**
- * @note the returned string will av_malloc()ed and must be av_free()ed by the caller
+ * @note the returned string will be av_malloc()ed and must be av_free()ed by the caller
  *)
 function av_opt_get           (obj: pointer; name: {const} PAnsiChar; search_flags: cint; out out_val: Pcuint8):     cint;
   cdecl; external av__util;
@@ -558,8 +567,10 @@ function av_opt_get_sample_fmt(obj: pointer; name: {const} PAnsiChar; search_fla
   cdecl; external av__util;
 function av_opt_get_video_rate(obj: pointer; name: {const} PAnsiChar; search_flags: cint; out_val: PAVRational):     cint;
   cdecl; external av__util;
+function av_opt_get_channel_layout(obj: pointer; name: {const} PAnsiChar; search_flags: cint; ch_layout: Pcint64):   cint;
+  cdecl; external av__util;
 (**
- * @}
+ * @
  *)
 (**
  * Gets a pointer to the requested field in a struct.
@@ -610,5 +621,5 @@ function av_opt_query_ranges_default(P: PPAVOptionRanges; obj: pointer; key: {co
   cdecl; external av__util;
 
 (**
- * @}
+ * @
  *)
diff --git a/src/lib/ffmpeg-2.1/libavutil/pixfmt.pas b/src/lib/ffmpeg-2.1/libavutil/pixfmt.pas
index c80e13d1..da672735 100644
--- a/src/lib/ffmpeg-2.1/libavutil/pixfmt.pas
+++ b/src/lib/ffmpeg-2.1/libavutil/pixfmt.pas
@@ -19,7 +19,7 @@
  * - Changes and updates by the UltraStar Deluxe Team
  *
  * Conversion of libavutil/pixfmt.h
- * avutil version 52.38.100
+ * avutil version 52.48.100
  *
  *)
 
@@ -37,17 +37,17 @@ type
  * Pixel format. Notes:
  *
  * @note
- * PIX_FMT_RGB32 is handled in an endian-specific manner. An RGBA
+ * AV_PIX_FMT_RGB32 is handled in an endian-specific manner. An RGBA
  * color is put together as:
  *  (A << 24) | (R << 16) | (G << 8) | B
  * This is stored as BGRA on little-endian CPU architectures and ARGB on
  * big-endian CPUs.
  *
  * @par
- * When the pixel format is palettized RGB (PIX_FMT_PAL8), the palettized
+ * When the pixel format is palettized RGB (AV_PIX_FMT_PAL8), the palettized
  * image data is stored in AVFrame.data[0]. The palette is transported in
  * AVFrame.data[1], is 1024 bytes long (256 4-byte entries) and is
- * formatted the same as in PIX_FMT_RGB32 described above (i.e., it is
+ * formatted the same as in AV_PIX_FMT_RGB32 described above (i.e., it is
  * also endian-specific). Note also that the individual RGB palette
  * components stored in AVFrame.data[1] should be in the range 0..255.
  * This is important as many custom PAL8 video codecs that were designed
@@ -59,9 +59,9 @@ type
  * allocating the picture.
  *
  * @note
- * make sure that all newly added big endian formats have pix_fmt&1==1
- * and that all newly added little endian formats have pix_fmt&1==0
- * this allows simpler detection of big vs little endian.
+ * Make sure that all newly added big-endian formats have (pix_fmt & 1) == 1
+ * and that all newly added little-endian formats have (pix_fmt & 1) == 0.
+ * This allows simpler detection of big vs little-endian.
  *)
 
   PAVPixelFormat = ^TAVPixelFormat;
@@ -144,9 +144,11 @@ type
     AV_PIX_FMT_BGR48BE,   ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian
     AV_PIX_FMT_BGR48LE,   ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian
 
-    //the following 10 formats have the disadvantage of needing 1 format for each bit depth, thus
-    //If you want to support multiple bit depths, then using AV_PIX_FMT_YUV420P16* with the bpp stored separately
-    //is better
+    (**
+     * The following 12 formats have the disadvantage of needing 1 format for each bit depth.
+     * Notice that each 9/10 bits sample is stored in 16 bits with extra padding.
+     * If you want to support multiple bit depths, then using AV_PIX_FMT_YUV420P16* with the bpp stored separately is better.
+     *)
     AV_PIX_FMT_YUV420P9BE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
     AV_PIX_FMT_YUV420P9LE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
     AV_PIX_FMT_YUV420P10BE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
@@ -204,6 +206,12 @@ type
 
     AV_PIX_FMT_VDPAU,        ///< HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface
 
+    AV_PIX_FMT_XYZ12LE,      ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as little-endian, the 4 lower bits are set to 0
+    AV_PIX_FMT_XYZ12BE,      ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big-endian, the 4 lower bits are set to 0
+    AV_PIX_FMT_NV16,         ///< interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
+    AV_PIX_FMT_NV20LE,       ///< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
+    AV_PIX_FMT_NV20BE,       ///< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
+
 {$IFNDEF AV_PIX_FMT_ABI_GIT_MASTER}
     AV_PIX_FMT_RGBA64BE = $123,  ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
     AV_PIX_FMT_RGBA64LE,  ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
@@ -233,11 +241,28 @@ type
     AV_PIX_FMT_GBRP12LE,    ///< planar GBR 4:4:4 36bpp, little-endian
     AV_PIX_FMT_GBRP14BE,    ///< planar GBR 4:4:4 42bpp, big-endian
     AV_PIX_FMT_GBRP14LE,    ///< planar GBR 4:4:4 42bpp, little-endian
+    AV_PIX_FMT_GBRAP,       ///< planar GBRA 4:4:4:4 32bpp
+    AV_PIX_FMT_GBRAP16BE,   ///< planar GBRA 4:4:4:4 64bpp, big-endian
+    AV_PIX_FMT_GBRAP16LE,   ///< planar GBRA 4:4:4:4 64bpp, little-endian
+    AV_PIX_FMT_YUVJ411P,    ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of PIX_FMT_YUV411P and setting color_range
+
+    AV_PIX_FMT_BAYER_BGGR8,    ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples */
+    AV_PIX_FMT_BAYER_RGGB8,    ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples */
+    AV_PIX_FMT_BAYER_GBRG8,    ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples */
+    AV_PIX_FMT_BAYER_GRBG8,    ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples */
+    AV_PIX_FMT_BAYER_BGGR16LE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian */
+    AV_PIX_FMT_BAYER_BGGR16BE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian */
+    AV_PIX_FMT_BAYER_RGGB16LE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian */
+    AV_PIX_FMT_BAYER_RGGB16BE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian */
+    AV_PIX_FMT_BAYER_GBRG16LE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian */
+    AV_PIX_FMT_BAYER_GBRG16BE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian */
+    AV_PIX_FMT_BAYER_GRBG16LE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian */
+    AV_PIX_FMT_BAYER_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian */
 
     AV_PIX_FMT_NB        ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
   );
 
-{$IFDEF AV_HAVE_INCOMPATIBLE_FORK_ABI}
+{$IFDEF AV_HAVE_INCOMPATIBLE_LIBAV_ABI}
 const
     AV_PIX_FMT_YUVA422P = AV_PIX_FMT_YUVA422P_LIBAV;
     AV_PIX_FMT_YUVA444P = AV_PIX_FMT_YUVA444P_LIBAV;
@@ -288,6 +313,26 @@ const
     AV_PIX_FMT_GBRP12 = AV_PIX_FMT_GBRP12BE;
     AV_PIX_FMT_GBRP14 = AV_PIX_FMT_GBRP14BE;
     AV_PIX_FMT_GBRP16 = AV_PIX_FMT_GBRP16BE;
+    AV_PIX_FMT_GBRAP16 = AV_PIX_FMT_GBRAP16BE;
+
+    AV_PIX_FMT_BAYER_BGGR16 = AV_PIX_FMT_BAYER_BGGR16BE;
+    AV_PIX_FMT_BAYER_RGGB16 = AV_PIX_FMT_BAYER_RGGB16BE;
+    AV_PIX_FMT_BAYER_GBRG16 = AV_PIX_FMT_BAYER_GBRG16BE;
+    AV_PIX_FMT_BAYER_GRBG16 = AV_PIX_FMT_BAYER_GRBG16BE;
+
+    AV_PIX_FMT_YUVA420P9  = AV_PIX_FMT_YUVA420P9BE;
+    AV_PIX_FMT_YUVA422P9  = AV_PIX_FMT_YUVA422P9BE;
+    AV_PIX_FMT_YUVA444P9  = AV_PIX_FMT_YUVA444P9BE;
+    AV_PIX_FMT_YUVA420P10 = AV_PIX_FMT_YUVA420P10BE;
+    AV_PIX_FMT_YUVA422P10 = AV_PIX_FMT_YUVA422P10BE;
+    AV_PIX_FMT_YUVA444P10 = AV_PIX_FMT_YUVA444P10BE;
+    AV_PIX_FMT_YUVA420P16 = AV_PIX_FMT_YUVA420P16BE;
+    AV_PIX_FMT_YUVA422P16 = AV_PIX_FMT_YUVA422P16BE;
+    AV_PIX_FMT_YUVA444P16 = AV_PIX_FMT_YUVA444P16BE;
+
+    AV_PIX_FMT_XYZ12      = AV_PIX_FMT_XYZ12BE;
+    AV_PIX_FMT_NV20       = AV_PIX_FMT_NV20BE;
+
 {$ELSE}
     AV_PIX_FMT_RGB32   = AV_PIX_FMT_BGRA;
     AV_PIX_FMT_RGB32_1 = AV_PIX_FMT_ABGR;
@@ -329,6 +374,26 @@ const
     AV_PIX_FMT_GBRP12 = AV_PIX_FMT_GBRP12LE;
     AV_PIX_FMT_GBRP14 = AV_PIX_FMT_GBRP14LE;
     AV_PIX_FMT_GBRP16 = AV_PIX_FMT_GBRP16LE;
+    AV_PIX_FMT_GBRAP16 = AV_PIX_FMT_GBRAP16LE;
+
+    AV_PIX_FMT_BAYER_BGGR16 = AV_PIX_FMT_BAYER_BGGR16LE;
+    AV_PIX_FMT_BAYER_RGGB16 = AV_PIX_FMT_BAYER_RGGB16LE;
+    AV_PIX_FMT_BAYER_GBRG16 = AV_PIX_FMT_BAYER_GBRG16LE;
+    AV_PIX_FMT_BAYER_GRBG16 = AV_PIX_FMT_BAYER_GRBG16LE;
+
+    AV_PIX_FMT_YUVA420P9  = AV_PIX_FMT_YUVA420P9LE;
+    AV_PIX_FMT_YUVA422P9  = AV_PIX_FMT_YUVA422P9LE;
+    AV_PIX_FMT_YUVA444P9  = AV_PIX_FMT_YUVA444P9LE;
+    AV_PIX_FMT_YUVA420P10 = AV_PIX_FMT_YUVA420P10LE;
+    AV_PIX_FMT_YUVA422P10 = AV_PIX_FMT_YUVA422P10LE;
+    AV_PIX_FMT_YUVA444P10 = AV_PIX_FMT_YUVA444P10LE;
+    AV_PIX_FMT_YUVA420P16 = AV_PIX_FMT_YUVA420P16LE;
+    AV_PIX_FMT_YUVA422P16 = AV_PIX_FMT_YUVA422P16LE;
+    AV_PIX_FMT_YUVA444P16 = AV_PIX_FMT_YUVA444P16LE;
+
+    AV_PIX_FMT_XYZ12      = AV_PIX_FMT_XYZ12LE;
+    AV_PIX_FMT_NV20       = AV_PIX_FMT_NV20LE;
+
 {$ENDIF}
 
 {$IFDEF FF_API_PIX_FMT}
diff --git a/src/lib/ffmpeg-2.1/libavutil/samplefmt.pas b/src/lib/ffmpeg-2.1/libavutil/samplefmt.pas
index 877d6207..1da4372a 100644
--- a/src/lib/ffmpeg-2.1/libavutil/samplefmt.pas
+++ b/src/lib/ffmpeg-2.1/libavutil/samplefmt.pas
@@ -19,7 +19,7 @@
  * This is a part of the Pascal port of ffmpeg.
  *
  * Conversion of libavutil/samplefmt.h
- * avutil version 52.38.100
+ * avutil version 52.48.100
  *
  *)