Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 20 Aug 2012 15:15:15 +0000 (17:15 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 20 Aug 2012 15:31:55 +0000 (17:31 +0200)
* qatar/master:
  fate: Add FATE tests for the Ut Video encoder
  lavc: add Ut Video encoder
  mpegvideo_enc: remove stray duplicate line from 7f9aaa4
  swscale: x86: fix #endif comments in rgb2rgb template file
  avconv: mark more options as expert.
  avconv: split printing "main options" into global and per-file.
  avconv: refactor help printing.

Conflicts:
Changelog
ffmpeg_opt.c
ffserver.c
libavcodec/version.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
18 files changed:
1  2 
Changelog
cmdutils.c
cmdutils.h
doc/general.texi
ffmpeg_opt.c
ffplay.c
ffprobe.c
ffserver.c
libavcodec/Makefile
libavcodec/allcodecs.c
libavcodec/utvideo.c
libavcodec/utvideo.h
libavcodec/utvideodec.c
libavcodec/utvideoenc.c
libavcodec/version.h
tests/ref/fate/utvideoenc_yuv422_left
tests/ref/fate/utvideoenc_yuv422_median
tests/ref/fate/utvideoenc_yuv422_none

diff --cc Changelog
+++ b/Changelog
@@@ -21,128 -37,36 +21,129 @@@ version next
  - Microsoft Expression Encoder Screen decoder
  - RTMPS protocol support
  - RTMPTS protocol support
 -- JPEG 2000 encoding support through OpenJPEG
 -- G.723.1 demuxer and decoder
  - RTMPE protocol support
  - RTMPTE protocol support
 +- showwaves filter
 +- LucasArts SMUSH playback support
 +- SAMI, RealText and SubViewer demuxers and decoders
 +- Heart Of Darkness PAF playback support
 +- iec61883 device
 +- asettb filter
 +- new option: -progress
 +- 3GPP Timed Text encoder/decoder
 +- GeoTIFF decoder support
 +- ffmpeg -(no)stdin option
 +- Opus decoder using libopus
 +- caca output device using libcaca
 +- alphaextract and alphamerge filters
 +- concat filter
 +- flite filter
  - Canopus Lossless Codec decoder
 -- avconv -shortest option is now per-output file
 +- bitmap subtitles in filters (experimental and temporary)
 +- MP2 encoding via TwoLAME
 +- bmp parser
 +- smptebars source
 +- asetpts filter
 +- hue filter
 +- ICO muxer
 +- SubRip encoder and decoder without embedded timing
 +- edge detection filter
 +- framestep filter
 +- ffmpeg -shortest option is now per-output file
 +- volume measurement filter
+ - Ut Video encoder
  
  
 -version 0.8:
 +version 0.11:
  
 -- GSM audio parser
 -- SMJPEG muxer
 +- Fixes: CVE-2012-2772, CVE-2012-2774, CVE-2012-2775, CVE-2012-2776, CVE-2012-2777,
 +         CVE-2012-2779, CVE-2012-2782, CVE-2012-2783, CVE-2012-2784, CVE-2012-2785,
 +         CVE-2012-2786, CVE-2012-2787, CVE-2012-2788, CVE-2012-2789, CVE-2012-2790,
 +         CVE-2012-2791, CVE-2012-2792, CVE-2012-2793, CVE-2012-2794, CVE-2012-2795,
 +         CVE-2012-2796, CVE-2012-2797, CVE-2012-2798, CVE-2012-2799, CVE-2012-2800,
 +         CVE-2012-2801, CVE-2012-2802, CVE-2012-2803, CVE-2012-2804,
 +- v408 Quicktime and Microsoft AYUV Uncompressed 4:4:4:4 encoder and decoder
 +- setfield filter
 +- CDXL demuxer and decoder
 +- Apple ProRes encoder
 +- ffprobe -count_packets and -count_frames options
 +- Sun Rasterfile Encoder
 +- ID3v2 attached pictures reading and writing
 +- WMA Lossless decoder
 +- bluray protocol
 +- blackdetect filter
 +- libutvideo encoder wrapper (--enable-libutvideo)
 +- swapuv filter
 +- bbox filter
 +- XBM encoder and decoder
 +- RealAudio Lossless decoder
 +- ZeroCodec decoder
 +- tile video filter
 +- Metal Gear Solid: The Twin Snakes demuxer
 +- OpenEXR image decoder
 +- removelogo filter
 +- drop support for ffmpeg without libavfilter
 +- drawtext video filter: fontconfig support
 +- ffmpeg -benchmark_all option
 +- super2xsai filter ported from libmpcodecs
 +- add libavresample audio conversion library for compatibility
 +- MicroDVD decoder
 +- Avid Meridien (AVUI) encoder and decoder
 +- accept + prefix to -pix_fmt option to disable automatic conversions.
 +- complete audio filtering in libavfilter and ffmpeg
 +- add fps filter
 +- vorbis parser
 +- png parser
 +- audio mix filter
  
  
 -version 0.8_beta2:
 +version 0.10:
  
 +- Fixes: CVE-2011-3929, CVE-2011-3934, CVE-2011-3935, CVE-2011-3936,
 +         CVE-2011-3937, CVE-2011-3940, CVE-2011-3941, CVE-2011-3944,
 +         CVE-2011-3945, CVE-2011-3946, CVE-2011-3947, CVE-2011-3949,
 +         CVE-2011-3950, CVE-2011-3951, CVE-2011-3952
 +- v410 Quicktime Uncompressed 4:4:4 10-bit encoder and decoder
 +- SBaGen (SBG) binaural beats script demuxer
 +- OpenMG Audio muxer
 +- Timecode extraction in DV and MOV
 +- thumbnail video filter
 +- XML output in ffprobe
 +- asplit audio filter
 +- tinterlace video filter
 +- astreamsync audio filter
 +- amerge audio filter
 +- ISMV (Smooth Streaming) muxer
 +- GSM audio parser
 +- SMJPEG muxer
 +- XWD encoder and decoder
  - Automatic thread count based on detection number of (available) CPU cores
 -- Deprecate libpostproc. If desired, the switch --enable-postproc will
 -  enable it but it may be removed in a later Libav release.
 +- y41p Brooktree Uncompressed 4:1:1 12-bit encoder and decoder
 +- ffprobe -show_error option
 +- Avid 1:1 10-bit RGB Packer codec
 +- v308 Quicktime Uncompressed 4:4:4 encoder and decoder
 +- yuv4 libquicktime packed 4:2:0 encoder and decoder
 +- ffprobe -show_frames option
 +- silencedetect audio filter
 +- ffprobe -show_program_version, -show_library_versions, -show_versions options
  - rv34: frame-level multi-threading
  - optimized iMDCT transform on x86 using SSE for for mpegaudiodec
 +- Improved PGS subtitle decoder
 +- dumpgraph option to lavfi device
 +- r210 and r10k encoders
 +- ffwavesynth decoder
 +- aviocat tool
 +- ffeval tool
  
  
 -version 0.8_beta1:
 +version 0.9:
  
 +- openal input device added
 +- boxblur filter added
  - BWF muxer
  - Flash Screen Video 2 decoder
 -- ffplay/ffprobe/ffserver renamed to avplay/avprobe/avserver
 -- ffmpeg deprecated, added avconv, which is almost the same for now, except
 +- lavfi input device added
 +- added avconv, which is almost the same for now, except
  for a few incompatible changes in the options, which will hopefully make them
  easier to use. The changes are:
      * The options placement is now strictly enforced! While in theory the
diff --cc cmdutils.c
Simple merge
diff --cc cmdutils.h
Simple merge
@@@ -666,10 -620,8 +666,10 @@@ following image formats are supported
      @tab encoding supported through external library libtheora
  @item Tiertex Limited SEQ video  @tab     @tab  X
      @tab Codec used in DOS CD-ROM FlashBack game.
- @item Ut Video               @tab     @tab  X
+ @item Ut Video               @tab  X  @tab  X
  @item v210 QuickTime uncompressed 4:2:2 10-bit     @tab  X  @tab  X
 +@item v308 QuickTime uncompressed 4:4:4            @tab  X  @tab  X
 +@item v408 QuickTime uncompressed 4:4:4:4          @tab  X  @tab  X
  @item v410 QuickTime uncompressed 4:4:4 10-bit     @tab  X  @tab  X
  @item VBLE Lossless Codec    @tab     @tab  X
  @item VMware Screen Codec / VMware Video  @tab     @tab  X
diff --cc ffmpeg_opt.c
@@@ -2141,32 -1791,66 +2141,68 @@@ static int opt_filter_complex(const cha
  
  void show_help_default(const char *opt, const char *arg)
  {
-     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
+     /* per-file options have at least one of those set */
+     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_FUNC2;
+     int show_advanced = 0, show_avoptions = 0;
+     if (opt) {
+         if (!strcmp(opt, "long"))
+             show_advanced = 1;
+         else if (!strcmp(opt, "full"))
+             show_advanced = show_avoptions = 1;
+         else
+             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
+     }
  
      show_usage();
+     printf("Getting help:\n"
+            "    -h      -- print basic options\n"
+            "    -h long -- print more options\n"
+            "    -h full -- print all options (including all format and codec specific options, very long)\n"
+            "    See man %s for detailed description of the options.\n"
+            "\n", program_name);
      show_help_options(options, "Print help / information / capabilities:",
-                       OPT_EXIT, 0);
-     show_help_options(options, "Main options:",
-                       0, OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
-                       OPT_EXIT);
-     show_help_options(options, "Advanced options:",
-                       OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE);
+                       OPT_EXIT, 0, 0);
+     show_help_options(options, "Global options (affect whole program "
+                       "instead of just one file:",
+                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
+     if (show_advanced)
+         show_help_options(options, "Advanced global options:", OPT_EXPERT,
+                           per_file | OPT_EXIT, 0);
+     show_help_options(options, "Per-file main options:", 0,
+                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
+                       OPT_EXIT, per_file);
+     if (show_advanced)
+         show_help_options(options, "Advanced per-file options:",
+                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
      show_help_options(options, "Video options:",
-                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO);
-     show_help_options(options, "Advanced Video options:",
-                       OPT_EXPERT | OPT_VIDEO, OPT_AUDIO);
+                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
+     if (show_advanced)
+         show_help_options(options, "Advanced Video options:",
+                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
      show_help_options(options, "Audio options:",
-                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO);
-     show_help_options(options, "Advanced Audio options:",
-                       OPT_EXPERT | OPT_AUDIO, OPT_VIDEO);
+                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
+     if (show_advanced)
+         show_help_options(options, "Advanced Audio options:",
+                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
      show_help_options(options, "Subtitle options:",
-                       OPT_SUBTITLE, 0);
+                       OPT_SUBTITLE, 0, 0);
      printf("\n");
-     show_help_children(avcodec_get_class(), flags);
-     show_help_children(avformat_get_class(), flags);
-     show_help_children(sws_get_class(), flags);
-     show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
-     show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
+     if (show_avoptions) {
+         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
+         show_help_children(avcodec_get_class(), flags);
+         show_help_children(avformat_get_class(), flags);
+         show_help_children(sws_get_class(), flags);
++        show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
++        show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
+     }
  }
  
  void show_usage(void)
@@@ -2229,25 -1892,17 +2265,25 @@@ const OptionDef options[] = 
          "set the limit file size in bytes", "limit_size" },
      { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(start_time) },
          "set the start time offset", "time_off" },
-     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(input_ts_offset) },
+     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
          "set the input ts offset", "time_off" },
-     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC,             { .off = OFFSET(ts_scale) },
+     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
          "set the input ts scale", "scale" },
 +    { "timestamp",      HAS_ARG | OPT_FUNC2,                         { .func2_arg = opt_recording_timestamp },
 +        "set the recording timestamp ('now' to set the current time)", "time" },
      { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(metadata) },
          "add metadata", "string=string" },
-     { "dframes",        HAS_ARG | OPT_FUNC2,                         { .func2_arg = opt_data_frames },
+     { "dframes",        HAS_ARG | OPT_FUNC2 | OPT_EXPERT,            { .func2_arg = opt_data_frames },
          "set the number of data frames to record", "number" },
      { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
          "add timings for benchmarking" },
-     { "timelimit",      HAS_ARG,                                     { .func_arg = opt_timelimit },
 +    { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
 +      "add timings for each task" },
 +    { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
 +      "write program-readable progress information", "url" },
 +    { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
 +      "enable or disable interaction on standard input" },
+     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
          "set max runtime in seconds", "limit" },
      { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
          "dump each input packet" },
          "finish encoding within shortest input" },
      { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
          "timestamp discontinuity delta threshold", "threshold" },
-     { "xerror",         OPT_BOOL,                                    { &exit_on_error },
 +    { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
 +        "timestamp error delta threshold", "threshold" },
+     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
          "exit on error", "error" },
      { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC,            { .off = OFFSET(copy_initial_nonkeyframes) },
          "copy initial non-keyframes" },
          "create a complex filtergraph", "graph_description" },
      { "stats",          OPT_BOOL,                                    { &print_stats },
          "print progress report during encoding", },
-     { "attach",         HAS_ARG | OPT_FUNC2,                         { .func2_arg = opt_attach },
+     { "attach",         HAS_ARG | OPT_FUNC2 | OPT_EXPERT,            { .func2_arg = opt_attach },
          "add an attachment to the output file", "filename" },
-     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC,            { .off = OFFSET(dump_attachment) },
+     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
          "extract an attachment into a file", "filename" },
 -    { "cpuflags",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_cpuflags },
 -        "set CPU flags mask", "mask" },
 +    { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
 +        "print timestamp debugging info" },
  
      /* video options */
      { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_video_frames },
          "rate control override for specific intervals", "override" },
      { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_FUNC2,                          { .func2_arg = opt_video_codec },
          "force video codec ('copy' to copy stream)", "codec" },
-     { "sameq",        OPT_VIDEO | OPT_BOOL,                                      { &same_quant },
++    { "sameq",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &same_quant },
 +        "use same quantizer as source (implies VBR)" },
-     { "same_quant",   OPT_VIDEO | OPT_BOOL ,                                     { &same_quant },
+     { "same_quant",   OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &same_quant },
          "use same quantizer as source (implies VBR)" },
 +    { "timecode",     OPT_VIDEO | HAS_ARG | OPT_FUNC2,                           { .func2_arg = opt_timecode },
 +        "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
      { "pass",         OPT_VIDEO | HAS_ARG ,                                      { opt_pass },
          "select the pass number (1 or 2)", "n" },
 -    { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT,             { &pass_logfilename_prefix },
 +    { "passlogfile",  OPT_VIDEO | HAS_ARG,                                       { .func_arg = &opt_passlogfile },
          "select two pass log file name prefix", "prefix" },
      { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
          "this option is deprecated, use the yadif filter instead" },
      { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
          "set the initial demux-decode delay", "seconds" },
  
-     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(bitstream_filters) },
+     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
          "A comma-separated list of bitstream filters", "bitstream_filters" },
 -
 +    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_old2new },
 +        "deprecated", "audio bitstream_filters" },
 +    { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_old2new },
 +        "deprecated", "video bitstream_filters" },
 +
 +    { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_preset },
 +        "set the audio options to the indicated preset", "preset" },
 +    { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_preset },
 +        "set the video options to the indicated preset", "preset" },
 +    { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_preset },
 +        "set the subtitle options to the indicated preset", "preset" },
 +    { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, { .func2_arg = opt_preset },
 +        "set options from indicated preset file", "filename" },
      /* data codec support */
-     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, { .func2_arg = opt_data_codec },
+     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2 | OPT_EXPERT, { .func2_arg = opt_data_codec },
          "force data codec ('copy' to copy stream)", "codec" },
 +    { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
 +        "disable data" },
  
      { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
          "generic catch all option", "" },
diff --cc ffplay.c
Simple merge
diff --cc ffprobe.c
index c1a90de,0000000..196ee40
mode 100644,000000..100644
--- /dev/null
+++ b/ffprobe.c
@@@ -1,2204 -1,0 +1,2204 @@@
-     show_help_options(options, "Main options:", 0, 0);
 +/*
 + * Copyright (c) 2007-2010 Stefano Sabatini
 + *
 + * This file is part of FFmpeg.
 + *
 + * 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
 + */
 +
 +/**
 + * @file
 + * simple media prober based on the FFmpeg libraries
 + */
 +
 +#include "config.h"
 +#include "version.h"
 +
 +#include "libavformat/avformat.h"
 +#include "libavcodec/avcodec.h"
 +#include "libavutil/avstring.h"
 +#include "libavutil/bprint.h"
 +#include "libavutil/opt.h"
 +#include "libavutil/pixdesc.h"
 +#include "libavutil/dict.h"
 +#include "libavutil/libm.h"
 +#include "libavutil/timecode.h"
 +#include "libavdevice/avdevice.h"
 +#include "libswscale/swscale.h"
 +#include "libswresample/swresample.h"
 +#include "libpostproc/postprocess.h"
 +#include "cmdutils.h"
 +
 +const char program_name[] = "ffprobe";
 +const int program_birth_year = 2007;
 +
 +static int do_count_frames = 0;
 +static int do_count_packets = 0;
 +static int do_read_frames  = 0;
 +static int do_read_packets = 0;
 +static int do_show_error   = 0;
 +static int do_show_format  = 0;
 +static int do_show_frames  = 0;
 +static AVDictionary *fmt_entries_to_show = NULL;
 +static int do_show_packets = 0;
 +static int do_show_streams = 0;
 +static int do_show_data    = 0;
 +static int do_show_program_version  = 0;
 +static int do_show_library_versions = 0;
 +
 +static int show_value_unit              = 0;
 +static int use_value_prefix             = 0;
 +static int use_byte_value_binary_prefix = 0;
 +static int use_value_sexagesimal_format = 0;
 +static int show_private_data            = 1;
 +
 +static char *print_format;
 +
 +static const OptionDef *options;
 +
 +/* FFprobe context */
 +static const char *input_filename;
 +static AVInputFormat *iformat = NULL;
 +
 +static const char *const binary_unit_prefixes [] = { "", "Ki", "Mi", "Gi", "Ti", "Pi" };
 +static const char *const decimal_unit_prefixes[] = { "", "K" , "M" , "G" , "T" , "P"  };
 +
 +static const char unit_second_str[]         = "s"    ;
 +static const char unit_hertz_str[]          = "Hz"   ;
 +static const char unit_byte_str[]           = "byte" ;
 +static const char unit_bit_per_second_str[] = "bit/s";
 +static uint64_t *nb_streams_packets;
 +static uint64_t *nb_streams_frames;
 +
 +void av_noreturn exit_program(int ret)
 +{
 +    av_dict_free(&fmt_entries_to_show);
 +    exit(ret);
 +}
 +
 +struct unit_value {
 +    union { double d; long long int i; } val;
 +    const char *unit;
 +};
 +
 +static char *value_string(char *buf, int buf_size, struct unit_value uv)
 +{
 +    double vald;
 +    int show_float = 0;
 +
 +    if (uv.unit == unit_second_str) {
 +        vald = uv.val.d;
 +        show_float = 1;
 +    } else {
 +        vald = uv.val.i;
 +    }
 +
 +    if (uv.unit == unit_second_str && use_value_sexagesimal_format) {
 +        double secs;
 +        int hours, mins;
 +        secs  = vald;
 +        mins  = (int)secs / 60;
 +        secs  = secs - mins * 60;
 +        hours = mins / 60;
 +        mins %= 60;
 +        snprintf(buf, buf_size, "%d:%02d:%09.6f", hours, mins, secs);
 +    } else {
 +        const char *prefix_string = "";
 +        int l;
 +
 +        if (use_value_prefix && vald > 1) {
 +            long long int index;
 +
 +            if (uv.unit == unit_byte_str && use_byte_value_binary_prefix) {
 +                index = (long long int) (log2(vald)) / 10;
 +                index = av_clip(index, 0, FF_ARRAY_ELEMS(binary_unit_prefixes) - 1);
 +                vald /= pow(2, index * 10);
 +                prefix_string = binary_unit_prefixes[index];
 +            } else {
 +                index = (long long int) (log10(vald)) / 3;
 +                index = av_clip(index, 0, FF_ARRAY_ELEMS(decimal_unit_prefixes) - 1);
 +                vald /= pow(10, index * 3);
 +                prefix_string = decimal_unit_prefixes[index];
 +            }
 +        }
 +
 +        if (show_float || (use_value_prefix && vald != (long long int)vald))
 +            l = snprintf(buf, buf_size, "%f", vald);
 +        else
 +            l = snprintf(buf, buf_size, "%lld", (long long int)vald);
 +        snprintf(buf+l, buf_size-l, "%s%s%s", *prefix_string || show_value_unit ? " " : "",
 +                 prefix_string, show_value_unit ? uv.unit : "");
 +    }
 +
 +    return buf;
 +}
 +
 +/* WRITERS API */
 +
 +typedef struct WriterContext WriterContext;
 +
 +#define WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS 1
 +#define WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER 2
 +
 +typedef struct Writer {
 +    int priv_size;                  ///< private size for the writer context
 +    const char *name;
 +
 +    int  (*init)  (WriterContext *wctx, const char *args, void *opaque);
 +    void (*uninit)(WriterContext *wctx);
 +
 +    void (*print_header)(WriterContext *ctx);
 +    void (*print_footer)(WriterContext *ctx);
 +
 +    void (*print_chapter_header)(WriterContext *wctx, const char *);
 +    void (*print_chapter_footer)(WriterContext *wctx, const char *);
 +    void (*print_section_header)(WriterContext *wctx, const char *);
 +    void (*print_section_footer)(WriterContext *wctx, const char *);
 +    void (*print_integer)       (WriterContext *wctx, const char *, long long int);
 +    void (*print_rational)      (WriterContext *wctx, AVRational *q, char *sep);
 +    void (*print_string)        (WriterContext *wctx, const char *, const char *);
 +    void (*show_tags)           (WriterContext *wctx, AVDictionary *dict);
 +    int flags;                  ///< a combination or WRITER_FLAG_*
 +} Writer;
 +
 +struct WriterContext {
 +    const AVClass *class;           ///< class of the writer
 +    const Writer *writer;           ///< the Writer of which this is an instance
 +    char *name;                     ///< name of this writer instance
 +    void *priv;                     ///< private data for use by the filter
 +    unsigned int nb_item;           ///< number of the item printed in the given section, starting at 0
 +    unsigned int nb_section;        ///< number of the section printed in the given section sequence, starting at 0
 +    unsigned int nb_section_packet; ///< number of the packet section in case we are in "packets_and_frames" section
 +    unsigned int nb_section_frame;  ///< number of the frame  section in case we are in "packets_and_frames" section
 +    unsigned int nb_section_packet_frame; ///< nb_section_packet or nb_section_frame according if is_packets_and_frames
 +    unsigned int nb_chapter;        ///< number of the chapter, starting at 0
 +
 +    int multiple_sections;          ///< tells if the current chapter can contain multiple sections
 +    int is_fmt_chapter;             ///< tells if the current chapter is "format", required by the print_format_entry option
 +    int is_packets_and_frames;      ///< tells if the current section is "packets_and_frames"
 +};
 +
 +static const char *writer_get_name(void *p)
 +{
 +    WriterContext *wctx = p;
 +    return wctx->writer->name;
 +}
 +
 +static const AVClass writer_class = {
 +    "Writer",
 +    writer_get_name,
 +    NULL,
 +    LIBAVUTIL_VERSION_INT,
 +};
 +
 +static void writer_close(WriterContext **wctx)
 +{
 +    if (!*wctx)
 +        return;
 +
 +    if ((*wctx)->writer->uninit)
 +        (*wctx)->writer->uninit(*wctx);
 +    av_freep(&((*wctx)->priv));
 +    av_freep(wctx);
 +}
 +
 +static int writer_open(WriterContext **wctx, const Writer *writer,
 +                       const char *args, void *opaque)
 +{
 +    int ret = 0;
 +
 +    if (!(*wctx = av_malloc(sizeof(WriterContext)))) {
 +        ret = AVERROR(ENOMEM);
 +        goto fail;
 +    }
 +
 +    if (!((*wctx)->priv = av_mallocz(writer->priv_size))) {
 +        ret = AVERROR(ENOMEM);
 +        goto fail;
 +    }
 +
 +    (*wctx)->class = &writer_class;
 +    (*wctx)->writer = writer;
 +    if ((*wctx)->writer->init)
 +        ret = (*wctx)->writer->init(*wctx, args, opaque);
 +    if (ret < 0)
 +        goto fail;
 +
 +    return 0;
 +
 +fail:
 +    writer_close(wctx);
 +    return ret;
 +}
 +
 +static inline void writer_print_header(WriterContext *wctx)
 +{
 +    if (wctx->writer->print_header)
 +        wctx->writer->print_header(wctx);
 +    wctx->nb_chapter = 0;
 +}
 +
 +static inline void writer_print_footer(WriterContext *wctx)
 +{
 +    if (wctx->writer->print_footer)
 +        wctx->writer->print_footer(wctx);
 +}
 +
 +static inline void writer_print_chapter_header(WriterContext *wctx,
 +                                               const char *chapter)
 +{
 +    wctx->nb_section =
 +    wctx->nb_section_packet = wctx->nb_section_frame =
 +    wctx->nb_section_packet_frame = 0;
 +    wctx->is_packets_and_frames = !strcmp(chapter, "packets_and_frames");
 +    wctx->multiple_sections = !strcmp(chapter, "packets") || !strcmp(chapter, "frames" ) ||
 +                              wctx->is_packets_and_frames ||
 +                              !strcmp(chapter, "streams") || !strcmp(chapter, "library_versions");
 +    wctx->is_fmt_chapter = !strcmp(chapter, "format");
 +
 +    if (wctx->writer->print_chapter_header)
 +        wctx->writer->print_chapter_header(wctx, chapter);
 +}
 +
 +static inline void writer_print_chapter_footer(WriterContext *wctx,
 +                                               const char *chapter)
 +{
 +    if (wctx->writer->print_chapter_footer)
 +        wctx->writer->print_chapter_footer(wctx, chapter);
 +    wctx->nb_chapter++;
 +}
 +
 +static inline void writer_print_section_header(WriterContext *wctx,
 +                                               const char *section)
 +{
 +    if (wctx->is_packets_and_frames)
 +        wctx->nb_section_packet_frame = !strcmp(section, "packet") ? wctx->nb_section_packet
 +                                                                   : wctx->nb_section_frame;
 +    if (wctx->writer->print_section_header)
 +        wctx->writer->print_section_header(wctx, section);
 +    wctx->nb_item = 0;
 +}
 +
 +static inline void writer_print_section_footer(WriterContext *wctx,
 +                                               const char *section)
 +{
 +    if (wctx->writer->print_section_footer)
 +        wctx->writer->print_section_footer(wctx, section);
 +    if (wctx->is_packets_and_frames) {
 +        if (!strcmp(section, "packet")) wctx->nb_section_packet++;
 +        else                            wctx->nb_section_frame++;
 +    }
 +    wctx->nb_section++;
 +}
 +
 +static inline void writer_print_integer(WriterContext *wctx,
 +                                        const char *key, long long int val)
 +{
 +    if (!wctx->is_fmt_chapter || !fmt_entries_to_show || av_dict_get(fmt_entries_to_show, key, NULL, 0)) {
 +        wctx->writer->print_integer(wctx, key, val);
 +        wctx->nb_item++;
 +    }
 +}
 +
 +static inline void writer_print_rational(WriterContext *wctx,
 +                                         const char *key, AVRational q, char sep)
 +{
 +    AVBPrint buf;
 +    av_bprint_init(&buf, 0, AV_BPRINT_SIZE_AUTOMATIC);
 +    av_bprintf(&buf, "%d%c%d", q.num, sep, q.den);
 +    wctx->writer->print_string(wctx, key, buf.str);
 +    wctx->nb_item++;
 +}
 +
 +static inline void writer_print_string(WriterContext *wctx,
 +                                       const char *key, const char *val, int opt)
 +{
 +    if (opt && !(wctx->writer->flags & WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS))
 +        return;
 +    if (!wctx->is_fmt_chapter || !fmt_entries_to_show || av_dict_get(fmt_entries_to_show, key, NULL, 0)) {
 +        wctx->writer->print_string(wctx, key, val);
 +        wctx->nb_item++;
 +    }
 +}
 +
 +static void writer_print_time(WriterContext *wctx, const char *key,
 +                              int64_t ts, const AVRational *time_base, int is_duration)
 +{
 +    char buf[128];
 +
 +    if (!wctx->is_fmt_chapter || !fmt_entries_to_show || av_dict_get(fmt_entries_to_show, key, NULL, 0)) {
 +        if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
 +            writer_print_string(wctx, key, "N/A", 1);
 +        } else {
 +            double d = ts * av_q2d(*time_base);
 +            value_string(buf, sizeof(buf), (struct unit_value){.val.d=d, .unit=unit_second_str});
 +            writer_print_string(wctx, key, buf, 0);
 +        }
 +    }
 +}
 +
 +static void writer_print_ts(WriterContext *wctx, const char *key, int64_t ts, int is_duration)
 +{
 +    if ((!is_duration && ts == AV_NOPTS_VALUE) || (is_duration && ts == 0)) {
 +        writer_print_string(wctx, key, "N/A", 1);
 +    } else {
 +        writer_print_integer(wctx, key, ts);
 +    }
 +}
 +
 +static inline void writer_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    wctx->writer->show_tags(wctx, dict);
 +}
 +
 +static void writer_print_data(WriterContext *wctx, const char *name,
 +                              uint8_t *data, int size)
 +{
 +    AVBPrint bp;
 +    int offset = 0, l, i;
 +
 +    av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
 +    av_bprintf(&bp, "\n");
 +    while (size) {
 +        av_bprintf(&bp, "%08x: ", offset);
 +        l = FFMIN(size, 16);
 +        for (i = 0; i < l; i++) {
 +            av_bprintf(&bp, "%02x", data[i]);
 +            if (i & 1)
 +                av_bprintf(&bp, " ");
 +        }
 +        av_bprint_chars(&bp, ' ', 41 - 2 * i - i / 2);
 +        for (i = 0; i < l; i++)
 +            av_bprint_chars(&bp, data[i] - 32U < 95 ? data[i] : '.', 1);
 +        av_bprintf(&bp, "\n");
 +        offset += l;
 +        data   += l;
 +        size   -= l;
 +    }
 +    writer_print_string(wctx, name, bp.str, 0);
 +    av_bprint_finalize(&bp, NULL);
 +}
 +
 +#define MAX_REGISTERED_WRITERS_NB 64
 +
 +static const Writer *registered_writers[MAX_REGISTERED_WRITERS_NB + 1];
 +
 +static int writer_register(const Writer *writer)
 +{
 +    static int next_registered_writer_idx = 0;
 +
 +    if (next_registered_writer_idx == MAX_REGISTERED_WRITERS_NB)
 +        return AVERROR(ENOMEM);
 +
 +    registered_writers[next_registered_writer_idx++] = writer;
 +    return 0;
 +}
 +
 +static const Writer *writer_get_by_name(const char *name)
 +{
 +    int i;
 +
 +    for (i = 0; registered_writers[i]; i++)
 +        if (!strcmp(registered_writers[i]->name, name))
 +            return registered_writers[i];
 +
 +    return NULL;
 +}
 +
 +
 +/* WRITERS */
 +
 +/* Default output */
 +
 +typedef struct DefaultContext {
 +    const AVClass *class;
 +    int nokey;
 +    int noprint_wrappers;
 +} DefaultContext;
 +
 +#define OFFSET(x) offsetof(DefaultContext, x)
 +
 +static const AVOption default_options[] = {
 +    { "noprint_wrappers", "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
 +    { "nw",               "do not print headers and footers", OFFSET(noprint_wrappers), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
 +    { "nokey",          "force no key printing",     OFFSET(nokey),          AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
 +    { "nk",             "force no key printing",     OFFSET(nokey),          AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
 +    {NULL},
 +};
 +
 +static const char *default_get_name(void *ctx)
 +{
 +    return "default";
 +}
 +
 +static const AVClass default_class = {
 +    "DefaultContext",
 +    default_get_name,
 +    default_options
 +};
 +
 +static av_cold int default_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    DefaultContext *def = wctx->priv;
 +    int err;
 +
 +    def->class = &default_class;
 +    av_opt_set_defaults(def);
 +
 +    if (args &&
 +        (err = (av_set_options_string(def, args, "=", ":"))) < 0)
 +        return err;
 +
 +    return 0;
 +}
 +
 +static void default_print_footer(WriterContext *wctx)
 +{
 +    DefaultContext *def = wctx->priv;
 +
 +    if (!def->noprint_wrappers)
 +        printf("\n");
 +}
 +
 +static void default_print_chapter_header(WriterContext *wctx, const char *chapter)
 +{
 +    DefaultContext *def = wctx->priv;
 +
 +    if (!def->noprint_wrappers && wctx->nb_chapter)
 +        printf("\n");
 +}
 +
 +/* lame uppercasing routine, assumes the string is lower case ASCII */
 +static inline char *upcase_string(char *dst, size_t dst_size, const char *src)
 +{
 +    int i;
 +    for (i = 0; src[i] && i < dst_size-1; i++)
 +        dst[i] = av_toupper(src[i]);
 +    dst[i] = 0;
 +    return dst;
 +}
 +
 +static void default_print_section_header(WriterContext *wctx, const char *section)
 +{
 +    DefaultContext *def = wctx->priv;
 +    char buf[32];
 +
 +    if (wctx->nb_section)
 +        printf("\n");
 +    if (!def->noprint_wrappers)
 +        printf("[%s]\n", upcase_string(buf, sizeof(buf), section));
 +}
 +
 +static void default_print_section_footer(WriterContext *wctx, const char *section)
 +{
 +    DefaultContext *def = wctx->priv;
 +    char buf[32];
 +
 +    if (!def->noprint_wrappers)
 +        printf("[/%s]", upcase_string(buf, sizeof(buf), section));
 +}
 +
 +static void default_print_str(WriterContext *wctx, const char *key, const char *value)
 +{
 +    DefaultContext *def = wctx->priv;
 +    if (!def->nokey)
 +        printf("%s=", key);
 +    printf("%s\n", value);
 +}
 +
 +static void default_print_int(WriterContext *wctx, const char *key, long long int value)
 +{
 +    DefaultContext *def = wctx->priv;
 +
 +    if (!def->nokey)
 +        printf("%s=", key);
 +    printf("%lld\n", value);
 +}
 +
 +static void default_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    AVDictionaryEntry *tag = NULL;
 +    while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 +        if (!fmt_entries_to_show || (tag->key && av_dict_get(fmt_entries_to_show, tag->key, NULL, 0)))
 +            printf("TAG:");
 +        writer_print_string(wctx, tag->key, tag->value, 0);
 +    }
 +}
 +
 +static const Writer default_writer = {
 +    .name                  = "default",
 +    .priv_size             = sizeof(DefaultContext),
 +    .init                  = default_init,
 +    .print_footer          = default_print_footer,
 +    .print_chapter_header  = default_print_chapter_header,
 +    .print_section_header  = default_print_section_header,
 +    .print_section_footer  = default_print_section_footer,
 +    .print_integer         = default_print_int,
 +    .print_string          = default_print_str,
 +    .show_tags             = default_show_tags,
 +    .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
 +};
 +
 +/* Compact output */
 +
 +/**
 + * Apply C-language-like string escaping.
 + */
 +static const char *c_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
 +{
 +    const char *p;
 +
 +    for (p = src; *p; p++) {
 +        switch (*p) {
 +        case '\b': av_bprintf(dst, "%s", "\\b");  break;
 +        case '\f': av_bprintf(dst, "%s", "\\f");  break;
 +        case '\n': av_bprintf(dst, "%s", "\\n");  break;
 +        case '\r': av_bprintf(dst, "%s", "\\r");  break;
 +        case '\\': av_bprintf(dst, "%s", "\\\\"); break;
 +        default:
 +            if (*p == sep)
 +                av_bprint_chars(dst, '\\', 1);
 +            av_bprint_chars(dst, *p, 1);
 +        }
 +    }
 +    return dst->str;
 +}
 +
 +/**
 + * Quote fields containing special characters, check RFC4180.
 + */
 +static const char *csv_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
 +{
 +    const char *p;
 +    int quote = 0;
 +
 +    /* check if input needs quoting */
 +    for (p = src; *p; p++)
 +        if (*p == '"' || *p == sep || *p == '\n' || *p == '\r')
 +            quote = 1;
 +
 +    if (quote)
 +        av_bprint_chars(dst, '\"', 1);
 +
 +    for (p = src; *p; p++) {
 +        if (*p == '"')
 +            av_bprint_chars(dst, '\"', 1);
 +        av_bprint_chars(dst, *p, 1);
 +    }
 +    if (quote)
 +        av_bprint_chars(dst, '\"', 1);
 +    return dst->str;
 +}
 +
 +static const char *none_escape_str(AVBPrint *dst, const char *src, const char sep, void *log_ctx)
 +{
 +    return src;
 +}
 +
 +typedef struct CompactContext {
 +    const AVClass *class;
 +    char *item_sep_str;
 +    char item_sep;
 +    int nokey;
 +    char *escape_mode_str;
 +    const char * (*escape_str)(AVBPrint *dst, const char *src, const char sep, void *log_ctx);
 +} CompactContext;
 +
 +#undef OFFSET
 +#define OFFSET(x) offsetof(CompactContext, x)
 +
 +static const AVOption compact_options[]= {
 +    {"item_sep", "set item separator",    OFFSET(item_sep_str),    AV_OPT_TYPE_STRING, {.str="|"},  CHAR_MIN, CHAR_MAX },
 +    {"s",        "set item separator",    OFFSET(item_sep_str),    AV_OPT_TYPE_STRING, {.str="|"},  CHAR_MIN, CHAR_MAX },
 +    {"nokey",    "force no key printing", OFFSET(nokey),           AV_OPT_TYPE_INT,    {.dbl=0},    0,        1        },
 +    {"nk",       "force no key printing", OFFSET(nokey),           AV_OPT_TYPE_INT,    {.dbl=0},    0,        1        },
 +    {"escape",   "set escape mode",       OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"},  CHAR_MIN, CHAR_MAX },
 +    {"e",        "set escape mode",       OFFSET(escape_mode_str), AV_OPT_TYPE_STRING, {.str="c"},  CHAR_MIN, CHAR_MAX },
 +    {NULL},
 +};
 +
 +static const char *compact_get_name(void *ctx)
 +{
 +    return "compact";
 +}
 +
 +static const AVClass compact_class = {
 +    "CompactContext",
 +    compact_get_name,
 +    compact_options
 +};
 +
 +static av_cold int compact_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    CompactContext *compact = wctx->priv;
 +    int err;
 +
 +    compact->class = &compact_class;
 +    av_opt_set_defaults(compact);
 +
 +    if (args &&
 +        (err = (av_set_options_string(compact, args, "=", ":"))) < 0)
 +        return err;
 +    if (strlen(compact->item_sep_str) != 1) {
 +        av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",
 +               compact->item_sep_str);
 +        return AVERROR(EINVAL);
 +    }
 +    compact->item_sep = compact->item_sep_str[0];
 +
 +    if      (!strcmp(compact->escape_mode_str, "none")) compact->escape_str = none_escape_str;
 +    else if (!strcmp(compact->escape_mode_str, "c"   )) compact->escape_str = c_escape_str;
 +    else if (!strcmp(compact->escape_mode_str, "csv" )) compact->escape_str = csv_escape_str;
 +    else {
 +        av_log(wctx, AV_LOG_ERROR, "Unknown escape mode '%s'\n", compact->escape_mode_str);
 +        return AVERROR(EINVAL);
 +    }
 +
 +    return 0;
 +}
 +
 +static av_cold void compact_uninit(WriterContext *wctx)
 +{
 +    CompactContext *compact = wctx->priv;
 +
 +    av_freep(&compact->item_sep_str);
 +    av_freep(&compact->escape_mode_str);
 +}
 +
 +static void compact_print_section_header(WriterContext *wctx, const char *section)
 +{
 +    CompactContext *compact = wctx->priv;
 +
 +    printf("%s%c", section, compact->item_sep);
 +}
 +
 +static void compact_print_section_footer(WriterContext *wctx, const char *section)
 +{
 +    printf("\n");
 +}
 +
 +static void compact_print_str(WriterContext *wctx, const char *key, const char *value)
 +{
 +    CompactContext *compact = wctx->priv;
 +    AVBPrint buf;
 +
 +    if (wctx->nb_item) printf("%c", compact->item_sep);
 +    if (!compact->nokey)
 +        printf("%s=", key);
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    printf("%s", compact->escape_str(&buf, value, compact->item_sep, wctx));
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static void compact_print_int(WriterContext *wctx, const char *key, long long int value)
 +{
 +    CompactContext *compact = wctx->priv;
 +
 +    if (wctx->nb_item) printf("%c", compact->item_sep);
 +    if (!compact->nokey)
 +        printf("%s=", key);
 +    printf("%lld", value);
 +}
 +
 +static void compact_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    CompactContext *compact = wctx->priv;
 +    AVDictionaryEntry *tag = NULL;
 +    AVBPrint buf;
 +
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 +        if (wctx->nb_item) printf("%c", compact->item_sep);
 +        if (!compact->nokey) {
 +            av_bprint_clear(&buf);
 +            printf("tag:%s=", compact->escape_str(&buf, tag->key, compact->item_sep, wctx));
 +        }
 +        av_bprint_clear(&buf);
 +        printf("%s", compact->escape_str(&buf, tag->value, compact->item_sep, wctx));
 +    }
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static const Writer compact_writer = {
 +    .name                 = "compact",
 +    .priv_size            = sizeof(CompactContext),
 +    .init                 = compact_init,
 +    .uninit               = compact_uninit,
 +    .print_section_header = compact_print_section_header,
 +    .print_section_footer = compact_print_section_footer,
 +    .print_integer        = compact_print_int,
 +    .print_string         = compact_print_str,
 +    .show_tags            = compact_show_tags,
 +    .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
 +};
 +
 +/* CSV output */
 +
 +static av_cold int csv_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    return compact_init(wctx, "item_sep=,:nokey=1:escape=csv", opaque);
 +}
 +
 +static const Writer csv_writer = {
 +    .name                 = "csv",
 +    .priv_size            = sizeof(CompactContext),
 +    .init                 = csv_init,
 +    .uninit               = compact_uninit,
 +    .print_section_header = compact_print_section_header,
 +    .print_section_footer = compact_print_section_footer,
 +    .print_integer        = compact_print_int,
 +    .print_string         = compact_print_str,
 +    .show_tags            = compact_show_tags,
 +    .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS,
 +};
 +
 +/* Flat output */
 +
 +typedef struct FlatContext {
 +    const AVClass *class;
 +    const char *section, *chapter;
 +    const char *sep_str;
 +    char sep;
 +    int hierarchical;
 +} FlatContext;
 +
 +#undef OFFSET
 +#define OFFSET(x) offsetof(FlatContext, x)
 +
 +static const AVOption flat_options[]= {
 +    {"sep_char", "set separator",    OFFSET(sep_str),    AV_OPT_TYPE_STRING, {.str="."},  CHAR_MIN, CHAR_MAX },
 +    {"s",        "set separator",    OFFSET(sep_str),    AV_OPT_TYPE_STRING, {.str="."},  CHAR_MIN, CHAR_MAX },
 +    {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
 +    {"h",           "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
 +    {NULL},
 +};
 +
 +static const char *flat_get_name(void *ctx)
 +{
 +    return "flat";
 +}
 +
 +static const AVClass flat_class = {
 +    "FlatContext",
 +    flat_get_name,
 +    flat_options
 +};
 +
 +static av_cold int flat_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    FlatContext *flat = wctx->priv;
 +    int err;
 +
 +    flat->class = &flat_class;
 +    av_opt_set_defaults(flat);
 +
 +    if (args &&
 +        (err = (av_set_options_string(flat, args, "=", ":"))) < 0)
 +        return err;
 +    if (strlen(flat->sep_str) != 1) {
 +        av_log(wctx, AV_LOG_ERROR, "Item separator '%s' specified, but must contain a single character\n",
 +               flat->sep_str);
 +        return AVERROR(EINVAL);
 +    }
 +    flat->sep = flat->sep_str[0];
 +    return 0;
 +}
 +
 +static const char *flat_escape_key_str(AVBPrint *dst, const char *src, const char sep)
 +{
 +    const char *p;
 +
 +    for (p = src; *p; p++) {
 +        if (!((*p >= '0' && *p <= '9') ||
 +              (*p >= 'a' && *p <= 'z') ||
 +              (*p >= 'A' && *p <= 'Z')))
 +            av_bprint_chars(dst, '_', 1);
 +        else
 +            av_bprint_chars(dst, *p, 1);
 +    }
 +    return dst->str;
 +}
 +
 +static const char *flat_escape_value_str(AVBPrint *dst, const char *src)
 +{
 +    const char *p;
 +
 +    for (p = src; *p; p++) {
 +        switch (*p) {
 +        case '\n': av_bprintf(dst, "%s", "\\n");  break;
 +        case '\r': av_bprintf(dst, "%s", "\\r");  break;
 +        case '\\': av_bprintf(dst, "%s", "\\\\"); break;
 +        case '"':  av_bprintf(dst, "%s", "\\\""); break;
 +        case '`':  av_bprintf(dst, "%s", "\\`");  break;
 +        case '$':  av_bprintf(dst, "%s", "\\$");  break;
 +        default:   av_bprint_chars(dst, *p, 1);   break;
 +        }
 +    }
 +    return dst->str;
 +}
 +
 +static void flat_print_chapter_header(WriterContext *wctx, const char *chapter)
 +{
 +    FlatContext *flat = wctx->priv;
 +    flat->chapter = chapter;
 +}
 +
 +static void flat_print_section_header(WriterContext *wctx, const char *section)
 +{
 +    FlatContext *flat = wctx->priv;
 +    flat->section = section;
 +}
 +
 +static void flat_print_section(WriterContext *wctx)
 +{
 +    FlatContext *flat = wctx->priv;
 +    int n = wctx->is_packets_and_frames ? wctx->nb_section_packet_frame
 +                                        : wctx->nb_section;
 +
 +    if (flat->hierarchical && wctx->multiple_sections)
 +        printf("%s%c", flat->chapter, flat->sep);
 +    printf("%s%c", flat->section, flat->sep);
 +    if (wctx->multiple_sections)
 +        printf("%d%c", n, flat->sep);
 +}
 +
 +static void flat_print_int(WriterContext *wctx, const char *key, long long int value)
 +{
 +    flat_print_section(wctx);
 +    printf("%s=%lld\n", key, value);
 +}
 +
 +static void flat_print_str(WriterContext *wctx, const char *key, const char *value)
 +{
 +    FlatContext *flat = wctx->priv;
 +    AVBPrint buf;
 +
 +    flat_print_section(wctx);
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    printf("%s=", flat_escape_key_str(&buf, key, flat->sep));
 +    av_bprint_clear(&buf);
 +    printf("\"%s\"\n", flat_escape_value_str(&buf, value));
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static void flat_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    FlatContext *flat = wctx->priv;
 +    AVBPrint buf;
 +    AVDictionaryEntry *tag = NULL;
 +
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 +        flat_print_section(wctx);
 +        av_bprint_clear(&buf);
 +        printf("tags%c%s=", flat->sep, flat_escape_key_str(&buf, tag->key, flat->sep));
 +        av_bprint_clear(&buf);
 +        printf("\"%s\"\n", flat_escape_value_str(&buf, tag->value));
 +    }
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static const Writer flat_writer = {
 +    .name                  = "flat",
 +    .priv_size             = sizeof(FlatContext),
 +    .init                  = flat_init,
 +    .print_chapter_header  = flat_print_chapter_header,
 +    .print_section_header  = flat_print_section_header,
 +    .print_integer         = flat_print_int,
 +    .print_string          = flat_print_str,
 +    .show_tags             = flat_show_tags,
 +    .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS|WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
 +};
 +
 +/* INI format output */
 +
 +typedef struct {
 +    const AVClass *class;
 +    AVBPrint chapter_name, section_name;
 +    int hierarchical;
 +} INIContext;
 +
 +#undef OFFSET
 +#define OFFSET(x) offsetof(INIContext, x)
 +
 +static const AVOption ini_options[] = {
 +    {"hierarchical", "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
 +    {"h",           "specify if the section specification should be hierarchical", OFFSET(hierarchical), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1 },
 +    {NULL},
 +};
 +
 +static const char *ini_get_name(void *ctx)
 +{
 +    return "ini";
 +}
 +
 +static const AVClass ini_class = {
 +    "INIContext",
 +    ini_get_name,
 +    ini_options
 +};
 +
 +static av_cold int ini_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    INIContext *ini = wctx->priv;
 +    int err;
 +
 +    av_bprint_init(&ini->chapter_name, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    av_bprint_init(&ini->section_name, 1, AV_BPRINT_SIZE_UNLIMITED);
 +
 +    ini->class = &ini_class;
 +    av_opt_set_defaults(ini);
 +
 +    if (args && (err = av_set_options_string(ini, args, "=", ":")) < 0)
 +        return err;
 +
 +    return 0;
 +}
 +
 +static av_cold void ini_uninit(WriterContext *wctx)
 +{
 +    INIContext *ini = wctx->priv;
 +    av_bprint_finalize(&ini->chapter_name, NULL);
 +    av_bprint_finalize(&ini->section_name, NULL);
 +}
 +
 +static void ini_print_header(WriterContext *wctx)
 +{
 +    printf("# ffprobe output\n\n");
 +}
 +
 +static char *ini_escape_str(AVBPrint *dst, const char *src)
 +{
 +    int i = 0;
 +    char c = 0;
 +
 +    while (c = src[i++]) {
 +        switch (c) {
 +        case '\b': av_bprintf(dst, "%s", "\\b"); break;
 +        case '\f': av_bprintf(dst, "%s", "\\f"); break;
 +        case '\n': av_bprintf(dst, "%s", "\\n"); break;
 +        case '\r': av_bprintf(dst, "%s", "\\r"); break;
 +        case '\t': av_bprintf(dst, "%s", "\\t"); break;
 +        case '\\':
 +        case '#' :
 +        case '=' :
 +        case ':' : av_bprint_chars(dst, '\\', 1);
 +        default:
 +            if ((unsigned char)c < 32)
 +                av_bprintf(dst, "\\x00%02x", c & 0xff);
 +            else
 +                av_bprint_chars(dst, c, 1);
 +            break;
 +        }
 +    }
 +    return dst->str;
 +}
 +
 +static void ini_print_chapter_header(WriterContext *wctx, const char *chapter)
 +{
 +    INIContext *ini = wctx->priv;
 +
 +    av_bprint_clear(&ini->chapter_name);
 +    av_bprintf(&ini->chapter_name, "%s", chapter);
 +
 +    if (wctx->nb_chapter)
 +        printf("\n");
 +}
 +
 +static void ini_print_section_header(WriterContext *wctx, const char *section)
 +{
 +    INIContext *ini = wctx->priv;
 +    int n = wctx->is_packets_and_frames ? wctx->nb_section_packet_frame
 +                                        : wctx->nb_section;
 +    if (wctx->nb_section)
 +        printf("\n");
 +    av_bprint_clear(&ini->section_name);
 +
 +    if (ini->hierarchical && wctx->multiple_sections)
 +        av_bprintf(&ini->section_name, "%s.", ini->chapter_name.str);
 +    av_bprintf(&ini->section_name, "%s", section);
 +
 +    if (wctx->multiple_sections)
 +        av_bprintf(&ini->section_name, ".%d", n);
 +    printf("[%s]\n", ini->section_name.str);
 +}
 +
 +static void ini_print_str(WriterContext *wctx, const char *key, const char *value)
 +{
 +    AVBPrint buf;
 +
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    printf("%s=", ini_escape_str(&buf, key));
 +    av_bprint_clear(&buf);
 +    printf("%s\n", ini_escape_str(&buf, value));
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static void ini_print_int(WriterContext *wctx, const char *key, long long int value)
 +{
 +    printf("%s=%lld\n", key, value);
 +}
 +
 +static void ini_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    INIContext *ini = wctx->priv;
 +    AVDictionaryEntry *tag = NULL;
 +    int is_first = 1;
 +
 +    while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 +        if (is_first) {
 +            printf("\n[%s.tags]\n", ini->section_name.str);
 +            is_first = 0;
 +        }
 +        writer_print_string(wctx, tag->key, tag->value, 0);
 +    }
 +}
 +
 +static const Writer ini_writer = {
 +    .name                  = "ini",
 +    .priv_size             = sizeof(INIContext),
 +    .init                  = ini_init,
 +    .uninit                = ini_uninit,
 +    .print_header          = ini_print_header,
 +    .print_chapter_header  = ini_print_chapter_header,
 +    .print_section_header  = ini_print_section_header,
 +    .print_integer         = ini_print_int,
 +    .print_string          = ini_print_str,
 +    .show_tags             = ini_show_tags,
 +    .flags = WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS|WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
 +};
 +
 +/* JSON output */
 +
 +typedef struct {
 +    const AVClass *class;
 +    int indent_level;
 +    int compact;
 +    const char *item_sep, *item_start_end;
 +} JSONContext;
 +
 +#undef OFFSET
 +#define OFFSET(x) offsetof(JSONContext, x)
 +
 +static const AVOption json_options[]= {
 +    { "compact", "enable compact output", OFFSET(compact), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
 +    { "c",       "enable compact output", OFFSET(compact), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1 },
 +    { NULL }
 +};
 +
 +static const char *json_get_name(void *ctx)
 +{
 +    return "json";
 +}
 +
 +static const AVClass json_class = {
 +    "JSONContext",
 +    json_get_name,
 +    json_options
 +};
 +
 +static av_cold int json_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    JSONContext *json = wctx->priv;
 +    int err;
 +
 +    json->class = &json_class;
 +    av_opt_set_defaults(json);
 +
 +    if (args &&
 +        (err = (av_set_options_string(json, args, "=", ":"))) < 0)
 +        return err;
 +
 +    json->item_sep       = json->compact ? ", " : ",\n";
 +    json->item_start_end = json->compact ? " "  : "\n";
 +
 +    return 0;
 +}
 +
 +static const char *json_escape_str(AVBPrint *dst, const char *src, void *log_ctx)
 +{
 +    static const char json_escape[] = {'"', '\\', '\b', '\f', '\n', '\r', '\t', 0};
 +    static const char json_subst[]  = {'"', '\\',  'b',  'f',  'n',  'r',  't', 0};
 +    const char *p;
 +
 +    for (p = src; *p; p++) {
 +        char *s = strchr(json_escape, *p);
 +        if (s) {
 +            av_bprint_chars(dst, '\\', 1);
 +            av_bprint_chars(dst, json_subst[s - json_escape], 1);
 +        } else if ((unsigned char)*p < 32) {
 +            av_bprintf(dst, "\\u00%02x", *p & 0xff);
 +        } else {
 +            av_bprint_chars(dst, *p, 1);
 +        }
 +    }
 +    return dst->str;
 +}
 +
 +static void json_print_header(WriterContext *wctx)
 +{
 +    JSONContext *json = wctx->priv;
 +    printf("{");
 +    json->indent_level++;
 +}
 +
 +static void json_print_footer(WriterContext *wctx)
 +{
 +    JSONContext *json = wctx->priv;
 +    json->indent_level--;
 +    printf("\n}\n");
 +}
 +
 +#define JSON_INDENT() printf("%*c", json->indent_level * 4, ' ')
 +
 +static void json_print_chapter_header(WriterContext *wctx, const char *chapter)
 +{
 +    JSONContext *json = wctx->priv;
 +    AVBPrint buf;
 +
 +    if (wctx->nb_chapter)
 +        printf(",");
 +    printf("\n");
 +    if (wctx->multiple_sections) {
 +        JSON_INDENT();
 +        av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +        printf("\"%s\": [\n", json_escape_str(&buf, chapter, wctx));
 +        av_bprint_finalize(&buf, NULL);
 +        json->indent_level++;
 +    }
 +}
 +
 +static void json_print_chapter_footer(WriterContext *wctx, const char *chapter)
 +{
 +    JSONContext *json = wctx->priv;
 +
 +    if (wctx->multiple_sections) {
 +        printf("\n");
 +        json->indent_level--;
 +        JSON_INDENT();
 +        printf("]");
 +    }
 +}
 +
 +static void json_print_section_header(WriterContext *wctx, const char *section)
 +{
 +    JSONContext *json = wctx->priv;
 +
 +    if (wctx->nb_section)
 +        printf(",\n");
 +    JSON_INDENT();
 +    if (!wctx->multiple_sections)
 +        printf("\"%s\": ", section);
 +    printf("{%s", json->item_start_end);
 +    json->indent_level++;
 +    /* this is required so the parser can distinguish between packets and frames */
 +    if (wctx->is_packets_and_frames) {
 +        if (!json->compact)
 +            JSON_INDENT();
 +        printf("\"type\": \"%s\"%s", section, json->item_sep);
 +    }
 +}
 +
 +static void json_print_section_footer(WriterContext *wctx, const char *section)
 +{
 +    JSONContext *json = wctx->priv;
 +
 +    printf("%s", json->item_start_end);
 +    json->indent_level--;
 +    if (!json->compact)
 +        JSON_INDENT();
 +    printf("}");
 +}
 +
 +static inline void json_print_item_str(WriterContext *wctx,
 +                                       const char *key, const char *value)
 +{
 +    AVBPrint buf;
 +
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    printf("\"%s\":", json_escape_str(&buf, key,   wctx));
 +    av_bprint_clear(&buf);
 +    printf(" \"%s\"", json_escape_str(&buf, value, wctx));
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static void json_print_str(WriterContext *wctx, const char *key, const char *value)
 +{
 +    JSONContext *json = wctx->priv;
 +
 +    if (wctx->nb_item) printf("%s", json->item_sep);
 +    if (!json->compact)
 +        JSON_INDENT();
 +    json_print_item_str(wctx, key, value);
 +}
 +
 +static void json_print_int(WriterContext *wctx, const char *key, long long int value)
 +{
 +    JSONContext *json = wctx->priv;
 +    AVBPrint buf;
 +
 +    if (wctx->nb_item) printf("%s", json->item_sep);
 +    if (!json->compact)
 +        JSON_INDENT();
 +
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    printf("\"%s\": %lld", json_escape_str(&buf, key, wctx), value);
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static void json_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    JSONContext *json = wctx->priv;
 +    AVDictionaryEntry *tag = NULL;
 +    int is_first = 1;
 +    if (!dict)
 +        return;
 +    printf("%s", json->item_sep);
 +    if (!json->compact)
 +        JSON_INDENT();
 +    printf("\"tags\": {%s", json->item_start_end);
 +    json->indent_level++;
 +    while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 +        if (is_first) is_first = 0;
 +        else          printf("%s", json->item_sep);
 +        if (!json->compact)
 +            JSON_INDENT();
 +        json_print_item_str(wctx, tag->key, tag->value);
 +    }
 +    json->indent_level--;
 +    printf("%s", json->item_start_end);
 +    if (!json->compact)
 +        JSON_INDENT();
 +    printf("}");
 +}
 +
 +static const Writer json_writer = {
 +    .name                 = "json",
 +    .priv_size            = sizeof(JSONContext),
 +    .init                 = json_init,
 +    .print_header         = json_print_header,
 +    .print_footer         = json_print_footer,
 +    .print_chapter_header = json_print_chapter_header,
 +    .print_chapter_footer = json_print_chapter_footer,
 +    .print_section_header = json_print_section_header,
 +    .print_section_footer = json_print_section_footer,
 +    .print_integer        = json_print_int,
 +    .print_string         = json_print_str,
 +    .show_tags            = json_show_tags,
 +    .flags = WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
 +};
 +
 +/* XML output */
 +
 +typedef struct {
 +    const AVClass *class;
 +    int within_tag;
 +    int indent_level;
 +    int fully_qualified;
 +    int xsd_strict;
 +} XMLContext;
 +
 +#undef OFFSET
 +#define OFFSET(x) offsetof(XMLContext, x)
 +
 +static const AVOption xml_options[] = {
 +    {"fully_qualified", "specify if the output should be fully qualified", OFFSET(fully_qualified), AV_OPT_TYPE_INT, {.dbl=0},  0, 1 },
 +    {"q",               "specify if the output should be fully qualified", OFFSET(fully_qualified), AV_OPT_TYPE_INT, {.dbl=0},  0, 1 },
 +    {"xsd_strict",      "ensure that the output is XSD compliant",         OFFSET(xsd_strict),      AV_OPT_TYPE_INT, {.dbl=0},  0, 1 },
 +    {"x",               "ensure that the output is XSD compliant",         OFFSET(xsd_strict),      AV_OPT_TYPE_INT, {.dbl=0},  0, 1 },
 +    {NULL},
 +};
 +
 +static const char *xml_get_name(void *ctx)
 +{
 +    return "xml";
 +}
 +
 +static const AVClass xml_class = {
 +    "XMLContext",
 +    xml_get_name,
 +    xml_options
 +};
 +
 +static av_cold int xml_init(WriterContext *wctx, const char *args, void *opaque)
 +{
 +    XMLContext *xml = wctx->priv;
 +    int err;
 +
 +    xml->class = &xml_class;
 +    av_opt_set_defaults(xml);
 +
 +    if (args &&
 +        (err = (av_set_options_string(xml, args, "=", ":"))) < 0)
 +        return err;
 +
 +    if (xml->xsd_strict) {
 +        xml->fully_qualified = 1;
 +#define CHECK_COMPLIANCE(opt, opt_name)                                 \
 +        if (opt) {                                                      \
 +            av_log(wctx, AV_LOG_ERROR,                                  \
 +                   "XSD-compliant output selected but option '%s' was selected, XML output may be non-compliant.\n" \
 +                   "You need to disable such option with '-no%s'\n", opt_name, opt_name); \
 +            return AVERROR(EINVAL);                                     \
 +        }
 +        CHECK_COMPLIANCE(show_private_data, "private");
 +        CHECK_COMPLIANCE(show_value_unit,   "unit");
 +        CHECK_COMPLIANCE(use_value_prefix,  "prefix");
 +
 +        if (do_show_frames && do_show_packets) {
 +            av_log(wctx, AV_LOG_ERROR,
 +                   "Interleaved frames and packets are not allowed in XSD. "
 +                   "Select only one between the -show_frames and the -show_packets options.\n");
 +            return AVERROR(EINVAL);
 +        }
 +    }
 +
 +    return 0;
 +}
 +
 +static const char *xml_escape_str(AVBPrint *dst, const char *src, void *log_ctx)
 +{
 +    const char *p;
 +
 +    for (p = src; *p; p++) {
 +        switch (*p) {
 +        case '&' : av_bprintf(dst, "%s", "&amp;");  break;
 +        case '<' : av_bprintf(dst, "%s", "&lt;");   break;
 +        case '>' : av_bprintf(dst, "%s", "&gt;");   break;
 +        case '\"': av_bprintf(dst, "%s", "&quot;"); break;
 +        case '\'': av_bprintf(dst, "%s", "&apos;"); break;
 +        default: av_bprint_chars(dst, *p, 1);
 +        }
 +    }
 +
 +    return dst->str;
 +}
 +
 +static void xml_print_header(WriterContext *wctx)
 +{
 +    XMLContext *xml = wctx->priv;
 +    const char *qual = " xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' "
 +        "xmlns:ffprobe='http://www.ffmpeg.org/schema/ffprobe' "
 +        "xsi:schemaLocation='http://www.ffmpeg.org/schema/ffprobe ffprobe.xsd'";
 +
 +    printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
 +    printf("<%sffprobe%s>\n",
 +           xml->fully_qualified ? "ffprobe:" : "",
 +           xml->fully_qualified ? qual : "");
 +
 +    xml->indent_level++;
 +}
 +
 +static void xml_print_footer(WriterContext *wctx)
 +{
 +    XMLContext *xml = wctx->priv;
 +
 +    xml->indent_level--;
 +    printf("</%sffprobe>\n", xml->fully_qualified ? "ffprobe:" : "");
 +}
 +
 +#define XML_INDENT() printf("%*c", xml->indent_level * 4, ' ')
 +
 +static void xml_print_chapter_header(WriterContext *wctx, const char *chapter)
 +{
 +    XMLContext *xml = wctx->priv;
 +
 +    if (wctx->nb_chapter)
 +        printf("\n");
 +    if (wctx->multiple_sections) {
 +        XML_INDENT(); printf("<%s>\n", chapter);
 +        xml->indent_level++;
 +    }
 +}
 +
 +static void xml_print_chapter_footer(WriterContext *wctx, const char *chapter)
 +{
 +    XMLContext *xml = wctx->priv;
 +
 +    if (wctx->multiple_sections) {
 +        xml->indent_level--;
 +        XML_INDENT(); printf("</%s>\n", chapter);
 +    }
 +}
 +
 +static void xml_print_section_header(WriterContext *wctx, const char *section)
 +{
 +    XMLContext *xml = wctx->priv;
 +
 +    XML_INDENT(); printf("<%s ", section);
 +    xml->within_tag = 1;
 +}
 +
 +static void xml_print_section_footer(WriterContext *wctx, const char *section)
 +{
 +    XMLContext *xml = wctx->priv;
 +
 +    if (xml->within_tag)
 +        printf("/>\n");
 +    else {
 +        XML_INDENT(); printf("</%s>\n", section);
 +    }
 +}
 +
 +static void xml_print_str(WriterContext *wctx, const char *key, const char *value)
 +{
 +    AVBPrint buf;
 +
 +    if (wctx->nb_item)
 +        printf(" ");
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    printf("%s=\"%s\"", key, xml_escape_str(&buf, value, wctx));
 +    av_bprint_finalize(&buf, NULL);
 +}
 +
 +static void xml_print_int(WriterContext *wctx, const char *key, long long int value)
 +{
 +    if (wctx->nb_item)
 +        printf(" ");
 +    printf("%s=\"%lld\"", key, value);
 +}
 +
 +static void xml_show_tags(WriterContext *wctx, AVDictionary *dict)
 +{
 +    XMLContext *xml = wctx->priv;
 +    AVDictionaryEntry *tag = NULL;
 +    int is_first = 1;
 +    AVBPrint buf;
 +
 +    av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +    xml->indent_level++;
 +    while ((tag = av_dict_get(dict, "", tag, AV_DICT_IGNORE_SUFFIX))) {
 +        if (is_first) {
 +            /* close section tag */
 +            printf(">\n");
 +            xml->within_tag = 0;
 +            is_first = 0;
 +        }
 +        XML_INDENT();
 +
 +        av_bprint_clear(&buf);
 +        printf("<tag key=\"%s\"", xml_escape_str(&buf, tag->key, wctx));
 +        av_bprint_clear(&buf);
 +        printf(" value=\"%s\"/>\n", xml_escape_str(&buf, tag->value, wctx));
 +    }
 +    av_bprint_finalize(&buf, NULL);
 +    xml->indent_level--;
 +}
 +
 +static Writer xml_writer = {
 +    .name                 = "xml",
 +    .priv_size            = sizeof(XMLContext),
 +    .init                 = xml_init,
 +    .print_header         = xml_print_header,
 +    .print_footer         = xml_print_footer,
 +    .print_chapter_header = xml_print_chapter_header,
 +    .print_chapter_footer = xml_print_chapter_footer,
 +    .print_section_header = xml_print_section_header,
 +    .print_section_footer = xml_print_section_footer,
 +    .print_integer        = xml_print_int,
 +    .print_string         = xml_print_str,
 +    .show_tags            = xml_show_tags,
 +    .flags = WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER,
 +};
 +
 +static void writer_register_all(void)
 +{
 +    static int initialized;
 +
 +    if (initialized)
 +        return;
 +    initialized = 1;
 +
 +    writer_register(&default_writer);
 +    writer_register(&compact_writer);
 +    writer_register(&csv_writer);
 +    writer_register(&flat_writer);
 +    writer_register(&ini_writer);
 +    writer_register(&json_writer);
 +    writer_register(&xml_writer);
 +}
 +
 +#define print_fmt(k, f, ...) do {              \
 +    av_bprint_clear(&pbuf);                    \
 +    av_bprintf(&pbuf, f, __VA_ARGS__);         \
 +    writer_print_string(w, k, pbuf.str, 0);    \
 +} while (0)
 +
 +#define print_int(k, v)         writer_print_integer(w, k, v)
 +#define print_q(k, v, s)        writer_print_rational(w, k, v, s)
 +#define print_str(k, v)         writer_print_string(w, k, v, 0)
 +#define print_str_opt(k, v)     writer_print_string(w, k, v, 1)
 +#define print_time(k, v, tb)    writer_print_time(w, k, v, tb, 0)
 +#define print_ts(k, v)          writer_print_ts(w, k, v, 0)
 +#define print_duration_time(k, v, tb) writer_print_time(w, k, v, tb, 1)
 +#define print_duration_ts(k, v)       writer_print_ts(w, k, v, 1)
 +#define print_val(k, v, u)      writer_print_string(w, k, \
 +    value_string(val_str, sizeof(val_str), (struct unit_value){.val.i = v, .unit=u}), 0)
 +#define print_section_header(s) writer_print_section_header(w, s)
 +#define print_section_footer(s) writer_print_section_footer(w, s)
 +#define show_tags(metadata)     writer_show_tags(w, metadata)
 +
 +static void show_packet(WriterContext *w, AVFormatContext *fmt_ctx, AVPacket *pkt, int packet_idx)
 +{
 +    char val_str[128];
 +    AVStream *st = fmt_ctx->streams[pkt->stream_index];
 +    AVBPrint pbuf;
 +    const char *s;
 +
 +    av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +
 +    print_section_header("packet");
 +    s = av_get_media_type_string(st->codec->codec_type);
 +    if (s) print_str    ("codec_type", s);
 +    else   print_str_opt("codec_type", "unknown");
 +    print_int("stream_index",     pkt->stream_index);
 +    print_ts  ("pts",             pkt->pts);
 +    print_time("pts_time",        pkt->pts, &st->time_base);
 +    print_ts  ("dts",             pkt->dts);
 +    print_time("dts_time",        pkt->dts, &st->time_base);
 +    print_duration_ts("duration",        pkt->duration);
 +    print_duration_time("duration_time", pkt->duration, &st->time_base);
 +    print_duration_ts("convergence_duration", pkt->convergence_duration);
 +    print_duration_time("convergence_duration_time", pkt->convergence_duration, &st->time_base);
 +    print_val("size",             pkt->size, unit_byte_str);
 +    if (pkt->pos != -1) print_fmt    ("pos", "%"PRId64, pkt->pos);
 +    else                print_str_opt("pos", "N/A");
 +    print_fmt("flags", "%c",      pkt->flags & AV_PKT_FLAG_KEY ? 'K' : '_');
 +    if (do_show_data)
 +        writer_print_data(w, "data", pkt->data, pkt->size);
 +    print_section_footer("packet");
 +
 +    av_bprint_finalize(&pbuf, NULL);
 +    fflush(stdout);
 +}
 +
 +static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
 +                       AVFormatContext *fmt_ctx)
 +{
 +    AVBPrint pbuf;
 +    const char *s;
 +
 +    av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +
 +    print_section_header("frame");
 +
 +    s = av_get_media_type_string(stream->codec->codec_type);
 +    if (s) print_str    ("media_type", s);
 +    else   print_str_opt("media_type", "unknown");
 +    print_int("key_frame",              frame->key_frame);
 +    print_ts  ("pkt_pts",               frame->pkt_pts);
 +    print_time("pkt_pts_time",          frame->pkt_pts, &stream->time_base);
 +    print_ts  ("pkt_dts",               frame->pkt_dts);
 +    print_time("pkt_dts_time",          frame->pkt_dts, &stream->time_base);
 +    print_duration_ts  ("pkt_duration",      frame->pkt_duration);
 +    print_duration_time("pkt_duration_time", frame->pkt_duration, &stream->time_base);
 +    if (frame->pkt_pos != -1) print_fmt    ("pkt_pos", "%"PRId64, frame->pkt_pos);
 +    else                      print_str_opt("pkt_pos", "N/A");
 +
 +    switch (stream->codec->codec_type) {
 +        AVRational sar;
 +
 +    case AVMEDIA_TYPE_VIDEO:
 +        print_int("width",                  frame->width);
 +        print_int("height",                 frame->height);
 +        s = av_get_pix_fmt_name(frame->format);
 +        if (s) print_str    ("pix_fmt", s);
 +        else   print_str_opt("pix_fmt", "unknown");
 +        sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, frame);
 +        if (sar.num) {
 +            print_q("sample_aspect_ratio", sar, ':');
 +        } else {
 +            print_str_opt("sample_aspect_ratio", "N/A");
 +        }
 +        print_fmt("pict_type",              "%c", av_get_picture_type_char(frame->pict_type));
 +        print_int("coded_picture_number",   frame->coded_picture_number);
 +        print_int("display_picture_number", frame->display_picture_number);
 +        print_int("interlaced_frame",       frame->interlaced_frame);
 +        print_int("top_field_first",        frame->top_field_first);
 +        print_int("repeat_pict",            frame->repeat_pict);
 +        print_int("reference",              frame->reference);
 +        break;
 +
 +    case AVMEDIA_TYPE_AUDIO:
 +        s = av_get_sample_fmt_name(frame->format);
 +        if (s) print_str    ("sample_fmt", s);
 +        else   print_str_opt("sample_fmt", "unknown");
 +        print_int("nb_samples",         frame->nb_samples);
 +        print_int("channels", av_frame_get_channels(frame));
 +        if (av_frame_get_channel_layout(frame)) {
 +            av_bprint_clear(&pbuf);
 +            av_bprint_channel_layout(&pbuf, av_frame_get_channels(frame),
 +                                     av_frame_get_channel_layout(frame));
 +            print_str    ("channel_layout", pbuf.str);
 +        } else
 +            print_str_opt("channel_layout", "unknown");
 +        break;
 +    }
 +    show_tags(av_frame_get_metadata(frame));
 +
 +    print_section_footer("frame");
 +
 +    av_bprint_finalize(&pbuf, NULL);
 +    fflush(stdout);
 +}
 +
 +static av_always_inline int process_frame(WriterContext *w,
 +                                          AVFormatContext *fmt_ctx,
 +                                          AVFrame *frame, AVPacket *pkt)
 +{
 +    AVCodecContext *dec_ctx = fmt_ctx->streams[pkt->stream_index]->codec;
 +    int ret = 0, got_frame = 0;
 +
 +    avcodec_get_frame_defaults(frame);
 +    if (dec_ctx->codec) {
 +        switch (dec_ctx->codec_type) {
 +        case AVMEDIA_TYPE_VIDEO:
 +            ret = avcodec_decode_video2(dec_ctx, frame, &got_frame, pkt);
 +            break;
 +
 +        case AVMEDIA_TYPE_AUDIO:
 +            ret = avcodec_decode_audio4(dec_ctx, frame, &got_frame, pkt);
 +            break;
 +        }
 +    }
 +
 +    if (ret < 0)
 +        return ret;
 +    ret = FFMIN(ret, pkt->size); /* guard against bogus return values */
 +    pkt->data += ret;
 +    pkt->size -= ret;
 +    if (got_frame) {
 +        nb_streams_frames[pkt->stream_index]++;
 +        if (do_show_frames)
 +            show_frame(w, frame, fmt_ctx->streams[pkt->stream_index], fmt_ctx);
 +    }
 +    return got_frame;
 +}
 +
 +static void read_packets(WriterContext *w, AVFormatContext *fmt_ctx)
 +{
 +    AVPacket pkt, pkt1;
 +    AVFrame frame;
 +    int i = 0;
 +
 +    av_init_packet(&pkt);
 +
 +    while (!av_read_frame(fmt_ctx, &pkt)) {
 +        if (do_read_packets) {
 +            if (do_show_packets)
 +                show_packet(w, fmt_ctx, &pkt, i++);
 +            nb_streams_packets[pkt.stream_index]++;
 +        }
 +        if (do_read_frames) {
 +            pkt1 = pkt;
 +            while (pkt1.size && process_frame(w, fmt_ctx, &frame, &pkt1) > 0);
 +        }
 +        av_free_packet(&pkt);
 +    }
 +    av_init_packet(&pkt);
 +    pkt.data = NULL;
 +    pkt.size = 0;
 +    //Flush remaining frames that are cached in the decoder
 +    for (i = 0; i < fmt_ctx->nb_streams; i++) {
 +        pkt.stream_index = i;
 +        if (do_read_frames)
 +            while (process_frame(w, fmt_ctx, &frame, &pkt) > 0);
 +    }
 +}
 +
 +static void show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx)
 +{
 +    AVStream *stream = fmt_ctx->streams[stream_idx];
 +    AVCodecContext *dec_ctx;
 +    const AVCodec *dec;
 +    char val_str[128];
 +    const char *s;
 +    AVRational sar, dar;
 +    AVBPrint pbuf;
 +
 +    av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +
 +    print_section_header("stream");
 +
 +    print_int("index", stream->index);
 +
 +    if ((dec_ctx = stream->codec)) {
 +        const char *profile = NULL;
 +        if ((dec = dec_ctx->codec)) {
 +            print_str("codec_name",      dec->name);
 +            print_str("codec_long_name", dec->long_name);
 +        } else {
 +            print_str_opt("codec_name",      "unknown");
 +            print_str_opt("codec_long_name", "unknown");
 +        }
 +
 +        if (dec && (profile = av_get_profile_name(dec, dec_ctx->profile)))
 +            print_str("profile", profile);
 +        else
 +            print_str_opt("profile", "unknown");
 +
 +        s = av_get_media_type_string(dec_ctx->codec_type);
 +        if (s) print_str    ("codec_type", s);
 +        else   print_str_opt("codec_type", "unknown");
 +        print_q("codec_time_base", dec_ctx->time_base, '/');
 +
 +        /* print AVI/FourCC tag */
 +        av_get_codec_tag_string(val_str, sizeof(val_str), dec_ctx->codec_tag);
 +        print_str("codec_tag_string",    val_str);
 +        print_fmt("codec_tag", "0x%04x", dec_ctx->codec_tag);
 +
 +        switch (dec_ctx->codec_type) {
 +        case AVMEDIA_TYPE_VIDEO:
 +            print_int("width",        dec_ctx->width);
 +            print_int("height",       dec_ctx->height);
 +            print_int("has_b_frames", dec_ctx->has_b_frames);
 +            sar = av_guess_sample_aspect_ratio(fmt_ctx, stream, NULL);
 +            if (sar.den) {
 +                print_q("sample_aspect_ratio", sar, ':');
 +                av_reduce(&dar.num, &dar.den,
 +                          dec_ctx->width  * sar.num,
 +                          dec_ctx->height * sar.den,
 +                          1024*1024);
 +                print_q("display_aspect_ratio", dar, ':');
 +            } else {
 +                print_str_opt("sample_aspect_ratio", "N/A");
 +                print_str_opt("display_aspect_ratio", "N/A");
 +            }
 +            s = av_get_pix_fmt_name(dec_ctx->pix_fmt);
 +            if (s) print_str    ("pix_fmt", s);
 +            else   print_str_opt("pix_fmt", "unknown");
 +            print_int("level",   dec_ctx->level);
 +            if (dec_ctx->timecode_frame_start >= 0) {
 +                char tcbuf[AV_TIMECODE_STR_SIZE];
 +                av_timecode_make_mpeg_tc_string(tcbuf, dec_ctx->timecode_frame_start);
 +                print_str("timecode", tcbuf);
 +            } else {
 +                print_str_opt("timecode", "N/A");
 +            }
 +            break;
 +
 +        case AVMEDIA_TYPE_AUDIO:
 +            s = av_get_sample_fmt_name(dec_ctx->sample_fmt);
 +            if (s) print_str    ("sample_fmt", s);
 +            else   print_str_opt("sample_fmt", "unknown");
 +            print_val("sample_rate",     dec_ctx->sample_rate, unit_hertz_str);
 +            print_int("channels",        dec_ctx->channels);
 +            print_int("bits_per_sample", av_get_bits_per_sample(dec_ctx->codec_id));
 +            break;
 +        }
 +    } else {
 +        print_str_opt("codec_type", "unknown");
 +    }
 +    if (dec_ctx->codec && dec_ctx->codec->priv_class && show_private_data) {
 +        const AVOption *opt = NULL;
 +        while (opt = av_opt_next(dec_ctx->priv_data,opt)) {
 +            uint8_t *str;
 +            if (opt->flags) continue;
 +            if (av_opt_get(dec_ctx->priv_data, opt->name, 0, &str) >= 0) {
 +                print_str(opt->name, str);
 +                av_free(str);
 +            }
 +        }
 +    }
 +
 +    if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS) print_fmt    ("id", "0x%x", stream->id);
 +    else                                          print_str_opt("id", "N/A");
 +    print_q("r_frame_rate",   stream->r_frame_rate,   '/');
 +    print_q("avg_frame_rate", stream->avg_frame_rate, '/');
 +    print_q("time_base",      stream->time_base,      '/');
 +    print_time("start_time",    stream->start_time, &stream->time_base);
 +    print_time("duration",      stream->duration,   &stream->time_base);
 +    if (dec_ctx->bit_rate > 0) print_val    ("bit_rate", dec_ctx->bit_rate, unit_bit_per_second_str);
 +    else                       print_str_opt("bit_rate", "N/A");
 +    if (stream->nb_frames) print_fmt    ("nb_frames", "%"PRId64, stream->nb_frames);
 +    else                   print_str_opt("nb_frames", "N/A");
 +    if (nb_streams_frames[stream_idx])  print_fmt    ("nb_read_frames", "%"PRIu64, nb_streams_frames[stream_idx]);
 +    else                                print_str_opt("nb_read_frames", "N/A");
 +    if (nb_streams_packets[stream_idx]) print_fmt    ("nb_read_packets", "%"PRIu64, nb_streams_packets[stream_idx]);
 +    else                                print_str_opt("nb_read_packets", "N/A");
 +    if (do_show_data)
 +        writer_print_data(w, "extradata", dec_ctx->extradata,
 +                                          dec_ctx->extradata_size);
 +    show_tags(stream->metadata);
 +
 +    print_section_footer("stream");
 +    av_bprint_finalize(&pbuf, NULL);
 +    fflush(stdout);
 +}
 +
 +static void show_streams(WriterContext *w, AVFormatContext *fmt_ctx)
 +{
 +    int i;
 +    for (i = 0; i < fmt_ctx->nb_streams; i++)
 +        show_stream(w, fmt_ctx, i);
 +}
 +
 +static void show_format(WriterContext *w, AVFormatContext *fmt_ctx)
 +{
 +    char val_str[128];
 +    int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1;
 +
 +    print_section_header("format");
 +    print_str("filename",         fmt_ctx->filename);
 +    print_int("nb_streams",       fmt_ctx->nb_streams);
 +    print_str("format_name",      fmt_ctx->iformat->name);
 +    print_str("format_long_name", fmt_ctx->iformat->long_name);
 +    print_time("start_time",      fmt_ctx->start_time, &AV_TIME_BASE_Q);
 +    print_time("duration",        fmt_ctx->duration,   &AV_TIME_BASE_Q);
 +    if (size >= 0) print_val    ("size", size, unit_byte_str);
 +    else           print_str_opt("size", "N/A");
 +    if (fmt_ctx->bit_rate > 0) print_val    ("bit_rate", fmt_ctx->bit_rate, unit_bit_per_second_str);
 +    else                       print_str_opt("bit_rate", "N/A");
 +    show_tags(fmt_ctx->metadata);
 +    print_section_footer("format");
 +    fflush(stdout);
 +}
 +
 +static void show_error(WriterContext *w, int err)
 +{
 +    char errbuf[128];
 +    const char *errbuf_ptr = errbuf;
 +
 +    if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
 +        errbuf_ptr = strerror(AVUNERROR(err));
 +
 +    writer_print_chapter_header(w, "error");
 +    print_section_header("error");
 +    print_int("code", err);
 +    print_str("string", errbuf_ptr);
 +    print_section_footer("error");
 +    writer_print_chapter_footer(w, "error");
 +}
 +
 +static int open_input_file(AVFormatContext **fmt_ctx_ptr, const char *filename)
 +{
 +    int err, i;
 +    AVFormatContext *fmt_ctx = NULL;
 +    AVDictionaryEntry *t;
 +
 +    if ((err = avformat_open_input(&fmt_ctx, filename,
 +                                   iformat, &format_opts)) < 0) {
 +        print_error(filename, err);
 +        return err;
 +    }
 +    if ((t = av_dict_get(format_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
 +        av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
 +        return AVERROR_OPTION_NOT_FOUND;
 +    }
 +
 +
 +    /* fill the streams in the format context */
 +    if ((err = avformat_find_stream_info(fmt_ctx, NULL)) < 0) {
 +        print_error(filename, err);
 +        return err;
 +    }
 +
 +    av_dump_format(fmt_ctx, 0, filename, 0);
 +
 +    /* bind a decoder to each input stream */
 +    for (i = 0; i < fmt_ctx->nb_streams; i++) {
 +        AVStream *stream = fmt_ctx->streams[i];
 +        AVCodec *codec;
 +
 +        if (stream->codec->codec_id == AV_CODEC_ID_PROBE) {
 +            av_log(NULL, AV_LOG_ERROR,
 +                   "Failed to probe codec for input stream %d\n",
 +                    stream->index);
 +        } else if (!(codec = avcodec_find_decoder(stream->codec->codec_id))) {
 +            av_log(NULL, AV_LOG_ERROR,
 +                    "Unsupported codec with id %d for input stream %d\n",
 +                    stream->codec->codec_id, stream->index);
 +        } else if (avcodec_open2(stream->codec, codec, NULL) < 0) {
 +            av_log(NULL, AV_LOG_ERROR, "Error while opening codec for input stream %d\n",
 +                   stream->index);
 +        }
 +    }
 +
 +    *fmt_ctx_ptr = fmt_ctx;
 +    return 0;
 +}
 +
 +static void close_input_file(AVFormatContext **ctx_ptr)
 +{
 +    int i;
 +    AVFormatContext *fmt_ctx = *ctx_ptr;
 +
 +    /* close decoder for each stream */
 +    for (i = 0; i < fmt_ctx->nb_streams; i++)
 +        if (fmt_ctx->streams[i]->codec->codec_id != AV_CODEC_ID_NONE)
 +            avcodec_close(fmt_ctx->streams[i]->codec);
 +
 +    avformat_close_input(ctx_ptr);
 +}
 +
 +#define PRINT_CHAPTER(name) do {                                        \
 +    if (do_show_ ## name) {                                             \
 +        writer_print_chapter_header(wctx, #name);                       \
 +        show_ ## name (wctx, fmt_ctx);                                  \
 +        writer_print_chapter_footer(wctx, #name);                       \
 +    }                                                                   \
 +} while (0)
 +
 +static int probe_file(WriterContext *wctx, const char *filename)
 +{
 +    AVFormatContext *fmt_ctx;
 +    int ret;
 +
 +    do_read_frames = do_show_frames || do_count_frames;
 +    do_read_packets = do_show_packets || do_count_packets;
 +
 +    ret = open_input_file(&fmt_ctx, filename);
 +    if (ret >= 0) {
 +        nb_streams_frames  = av_calloc(fmt_ctx->nb_streams, sizeof(*nb_streams_frames));
 +        nb_streams_packets = av_calloc(fmt_ctx->nb_streams, sizeof(*nb_streams_packets));
 +        if (do_read_frames || do_read_packets) {
 +            const char *chapter;
 +            if (do_show_frames && do_show_packets &&
 +                wctx->writer->flags & WRITER_FLAG_PUT_PACKETS_AND_FRAMES_IN_SAME_CHAPTER)
 +                chapter = "packets_and_frames";
 +            else if (do_show_packets && !do_show_frames)
 +                chapter = "packets";
 +            else // (!do_show_packets && do_show_frames)
 +                chapter = "frames";
 +            if (do_show_frames || do_show_packets)
 +                writer_print_chapter_header(wctx, chapter);
 +            read_packets(wctx, fmt_ctx);
 +            if (do_show_frames || do_show_packets)
 +                writer_print_chapter_footer(wctx, chapter);
 +        }
 +        PRINT_CHAPTER(streams);
 +        PRINT_CHAPTER(format);
 +        close_input_file(&fmt_ctx);
 +        av_freep(&nb_streams_frames);
 +        av_freep(&nb_streams_packets);
 +    }
 +    return ret;
 +}
 +
 +static void show_usage(void)
 +{
 +    av_log(NULL, AV_LOG_INFO, "Simple multimedia streams analyzer\n");
 +    av_log(NULL, AV_LOG_INFO, "usage: %s [OPTIONS] [INPUT_FILE]\n", program_name);
 +    av_log(NULL, AV_LOG_INFO, "\n");
 +}
 +
 +static void ffprobe_show_program_version(WriterContext *w)
 +{
 +    AVBPrint pbuf;
 +    av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
 +
 +    writer_print_chapter_header(w, "program_version");
 +    print_section_header("program_version");
 +    print_str("version", FFMPEG_VERSION);
 +    print_fmt("copyright", "Copyright (c) %d-%d the FFmpeg developers",
 +              program_birth_year, this_year);
 +    print_str("build_date", __DATE__);
 +    print_str("build_time", __TIME__);
 +    print_str("compiler_ident", CC_IDENT);
 +    print_str("configuration", FFMPEG_CONFIGURATION);
 +    print_section_footer("program_version");
 +    writer_print_chapter_footer(w, "program_version");
 +
 +    av_bprint_finalize(&pbuf, NULL);
 +}
 +
 +#define SHOW_LIB_VERSION(libname, LIBNAME)                              \
 +    do {                                                                \
 +        if (CONFIG_##LIBNAME) {                                         \
 +            unsigned int version = libname##_version();                 \
 +            print_section_header("library_version");                    \
 +            print_str("name",    "lib" #libname);                       \
 +            print_int("major",   LIB##LIBNAME##_VERSION_MAJOR);         \
 +            print_int("minor",   LIB##LIBNAME##_VERSION_MINOR);         \
 +            print_int("micro",   LIB##LIBNAME##_VERSION_MICRO);         \
 +            print_int("version", version);                              \
 +            print_section_footer("library_version");                    \
 +        }                                                               \
 +    } while (0)
 +
 +static void ffprobe_show_library_versions(WriterContext *w)
 +{
 +    writer_print_chapter_header(w, "library_versions");
 +    SHOW_LIB_VERSION(avutil,     AVUTIL);
 +    SHOW_LIB_VERSION(avcodec,    AVCODEC);
 +    SHOW_LIB_VERSION(avformat,   AVFORMAT);
 +    SHOW_LIB_VERSION(avdevice,   AVDEVICE);
 +    SHOW_LIB_VERSION(avfilter,   AVFILTER);
 +    SHOW_LIB_VERSION(swscale,    SWSCALE);
 +    SHOW_LIB_VERSION(swresample, SWRESAMPLE);
 +    SHOW_LIB_VERSION(postproc,   POSTPROC);
 +    writer_print_chapter_footer(w, "library_versions");
 +}
 +
 +static int opt_format(const char *opt, const char *arg)
 +{
 +    iformat = av_find_input_format(arg);
 +    if (!iformat) {
 +        av_log(NULL, AV_LOG_ERROR, "Unknown input format: %s\n", arg);
 +        return AVERROR(EINVAL);
 +    }
 +    return 0;
 +}
 +
 +static int opt_show_format_entry(const char *opt, const char *arg)
 +{
 +    do_show_format = 1;
 +    av_dict_set(&fmt_entries_to_show, arg, "", 0);
 +    return 0;
 +}
 +
 +static void opt_input_file(void *optctx, const char *arg)
 +{
 +    if (input_filename) {
 +        av_log(NULL, AV_LOG_ERROR,
 +                "Argument '%s' provided as input filename, but '%s' was already specified.\n",
 +                arg, input_filename);
 +        exit(1);
 +    }
 +    if (!strcmp(arg, "-"))
 +        arg = "pipe:";
 +    input_filename = arg;
 +}
 +
 +void show_help_default(const char *opt, const char *arg)
 +{
 +    av_log_set_callback(log_callback_help);
 +    show_usage();
++    show_help_options(options, "Main options:", 0, 0, 0);
 +    printf("\n");
 +
 +    show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
 +}
 +
 +static int opt_pretty(const char *opt, const char *arg)
 +{
 +    show_value_unit              = 1;
 +    use_value_prefix             = 1;
 +    use_byte_value_binary_prefix = 1;
 +    use_value_sexagesimal_format = 1;
 +    return 0;
 +}
 +
 +static int opt_show_versions(const char *opt, const char *arg)
 +{
 +    do_show_program_version  = 1;
 +    do_show_library_versions = 1;
 +    return 0;
 +}
 +
 +static const OptionDef real_options[] = {
 +#include "cmdutils_common_opts.h"
 +    { "f", HAS_ARG, {(void*)opt_format}, "force format", "format" },
 +    { "unit", OPT_BOOL, {(void*)&show_value_unit}, "show unit of the displayed values" },
 +    { "prefix", OPT_BOOL, {(void*)&use_value_prefix}, "use SI prefixes for the displayed values" },
 +    { "byte_binary_prefix", OPT_BOOL, {(void*)&use_byte_value_binary_prefix},
 +      "use binary prefixes for byte units" },
 +    { "sexagesimal", OPT_BOOL,  {(void*)&use_value_sexagesimal_format},
 +      "use sexagesimal format HOURS:MM:SS.MICROSECONDS for time units" },
 +    { "pretty", 0, {(void*)&opt_pretty},
 +      "prettify the format of displayed values, make it more human readable" },
 +    { "print_format", OPT_STRING | HAS_ARG, {(void*)&print_format},
 +      "set the output printing format (available formats are: default, compact, csv, flat, ini, json, xml)", "format" },
 +    { "of", OPT_STRING | HAS_ARG, {(void*)&print_format}, "alias for -print_format", "format" },
 +    { "show_data",    OPT_BOOL, {(void*)&do_show_data}, "show packets data" },
 +    { "show_error",   OPT_BOOL, {(void*)&do_show_error} ,  "show probing error" },
 +    { "show_format",  OPT_BOOL, {(void*)&do_show_format} , "show format/container info" },
 +    { "show_frames",  OPT_BOOL, {(void*)&do_show_frames} , "show frames info" },
 +    { "show_format_entry", HAS_ARG, {(void*)opt_show_format_entry},
 +      "show a particular entry from the format/container info", "entry" },
 +    { "show_packets", OPT_BOOL, {(void*)&do_show_packets}, "show packets info" },
 +    { "show_streams", OPT_BOOL, {(void*)&do_show_streams}, "show streams info" },
 +    { "count_frames", OPT_BOOL, {(void*)&do_count_frames}, "count the number of frames per stream" },
 +    { "count_packets", OPT_BOOL, {(void*)&do_count_packets}, "count the number of packets per stream" },
 +    { "show_program_version",  OPT_BOOL, {(void*)&do_show_program_version},  "show ffprobe version" },
 +    { "show_library_versions", OPT_BOOL, {(void*)&do_show_library_versions}, "show library versions" },
 +    { "show_versions",         0, {(void*)&opt_show_versions}, "show program and library versions" },
 +    { "show_private_data", OPT_BOOL, {(void*)&show_private_data}, "show private data" },
 +    { "private",           OPT_BOOL, {(void*)&show_private_data}, "same as show_private_data" },
 +    { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
 +    { "i", HAS_ARG, {(void *)opt_input_file}, "read specified file", "input_file"},
 +    { NULL, },
 +};
 +
 +int main(int argc, char **argv)
 +{
 +    const Writer *w;
 +    WriterContext *wctx;
 +    char *buf;
 +    char *w_name = NULL, *w_args = NULL;
 +    int ret;
 +
 +    av_log_set_flags(AV_LOG_SKIP_REPEATED);
 +    options = real_options;
 +    parse_loglevel(argc, argv, options);
 +    av_register_all();
 +    avformat_network_init();
 +    init_opts();
 +#if CONFIG_AVDEVICE
 +    avdevice_register_all();
 +#endif
 +
 +    show_banner(argc, argv, options);
 +    parse_options(NULL, argc, argv, options, opt_input_file);
 +
 +    writer_register_all();
 +
 +    if (!print_format)
 +        print_format = av_strdup("default");
 +    w_name = av_strtok(print_format, "=", &buf);
 +    w_args = buf;
 +
 +    w = writer_get_by_name(w_name);
 +    if (!w) {
 +        av_log(NULL, AV_LOG_ERROR, "Unknown output format with name '%s'\n", w_name);
 +        ret = AVERROR(EINVAL);
 +        goto end;
 +    }
 +
 +    if ((ret = writer_open(&wctx, w, w_args, NULL)) >= 0) {
 +        writer_print_header(wctx);
 +
 +        if (do_show_program_version)
 +            ffprobe_show_program_version(wctx);
 +        if (do_show_library_versions)
 +            ffprobe_show_library_versions(wctx);
 +
 +        if (!input_filename &&
 +            ((do_show_format || do_show_streams || do_show_packets || do_show_error) ||
 +             (!do_show_program_version && !do_show_library_versions))) {
 +            show_usage();
 +            av_log(NULL, AV_LOG_ERROR, "You have to specify one input file.\n");
 +            av_log(NULL, AV_LOG_ERROR, "Use -h to get full help or, even better, run 'man %s'.\n", program_name);
 +            ret = AVERROR(EINVAL);
 +        } else if (input_filename) {
 +            ret = probe_file(wctx, input_filename);
 +            if (ret < 0 && do_show_error)
 +                show_error(wctx, ret);
 +        }
 +
 +        writer_print_footer(wctx);
 +        writer_close(&wctx);
 +    }
 +
 +end:
 +    av_freep(&print_format);
 +
 +    uninit_opts();
 +    av_dict_free(&fmt_entries_to_show);
 +
 +    avformat_network_deinit();
 +
 +    return ret;
 +}
diff --cc ffserver.c
@@@ -4647,11 -4631,10 +4647,10 @@@ static void opt_debug(void
  
  void show_help_default(const char *opt, const char *arg)
  {
 -    printf("usage: avserver [options]\n"
 +    printf("usage: ffserver [options]\n"
             "Hyper fast multi format Audio/Video streaming server\n");
      printf("\n");
-     show_help_options(options, "Main options:", 0, 0);
-     return 0;
+     show_help_options(options, "Main options:", 0, 0, 0);
  }
  
  static const OptionDef options[] = {
@@@ -432,13 -377,10 +432,14 @@@ OBJS-$(CONFIG_TTA_DECODER)             
  OBJS-$(CONFIG_TWINVQ_DECODER)          += twinvq.o celp_math.o
  OBJS-$(CONFIG_TXD_DECODER)             += txd.o s3tc.o
  OBJS-$(CONFIG_ULTI_DECODER)            += ulti.o
- OBJS-$(CONFIG_UTVIDEO_DECODER)         += utvideodec.o
+ OBJS-$(CONFIG_UTVIDEO_DECODER)         += utvideodec.o utvideo.o
+ OBJS-$(CONFIG_UTVIDEO_ENCODER)         += utvideoenc.o utvideo.o
  OBJS-$(CONFIG_V210_DECODER)            += v210dec.o
  OBJS-$(CONFIG_V210_ENCODER)            += v210enc.o
 +OBJS-$(CONFIG_V308_DECODER)            += v308dec.o
 +OBJS-$(CONFIG_V308_ENCODER)            += v308enc.o
 +OBJS-$(CONFIG_V408_DECODER)            += v408dec.o
 +OBJS-$(CONFIG_V408_ENCODER)            += v408enc.o
  OBJS-$(CONFIG_V410_DECODER)            += v410dec.o
  OBJS-$(CONFIG_V410_ENCODER)            += v410enc.o
  OBJS-$(CONFIG_V210X_DECODER)           += v210x.o
@@@ -229,11 -209,9 +229,11 @@@ void avcodec_register_all(void
      REGISTER_DECODER (TSCC2, tscc2);
      REGISTER_DECODER (TXD, txd);
      REGISTER_DECODER (ULTI, ulti);
-     REGISTER_DECODER (UTVIDEO, utvideo);
+     REGISTER_ENCDEC  (UTVIDEO, utvideo);
      REGISTER_ENCDEC  (V210,  v210);
      REGISTER_DECODER (V210X, v210x);
 +    REGISTER_ENCDEC  (V308, v308);
 +    REGISTER_ENCDEC  (V408, v408);
      REGISTER_ENCDEC  (V410, v410);
      REGISTER_DECODER (VB, vb);
      REGISTER_DECODER (VBLE, vble);
index 0000000,eb5a924..308adb7
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,39 +1,39 @@@
 - * This file is part of Libav.
+ /*
+  * Common Ut Video code
+  * Copyright (c) 2011 Konstantin Shishkov
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
+  */
+ /**
+  * @file
+  * Common Ut Video code
+  */
+ #include "utvideo.h"
+ const int ff_ut_pred_order[5] = {
+     PRED_LEFT, PRED_MEDIAN, PRED_MEDIAN, PRED_NONE, PRED_GRADIENT
+ };
+ const int ff_ut_rgb_order[4]  = { 1, 2, 0, 3 }; // G, B, R, A
+ int ff_ut_huff_cmp_len(const void *a, const void *b)
+ {
+     const HuffEntry *aa = a, *bb = b;
+     return (aa->len - bb->len)*256 + aa->sym - bb->sym;
+ }
index 0000000,ed6ae86..00c44be
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,91 +1,91 @@@
 - * This file is part of Libav.
+ /*
+  * Common Ut Video header
+  * Copyright (c) 2011 Konstantin Shishkov
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
+  */
+ #ifndef AVCODEC_UTVIDEO_H
+ #define AVCODEC_UTVIDEO_H
+ /**
+  * @file
+  * Common Ut Video header
+  */
+ #include "libavutil/common.h"
+ #include "avcodec.h"
+ #include "dsputil.h"
+ enum {
+     PRED_NONE = 0,
+     PRED_LEFT,
+     PRED_GRADIENT,
+     PRED_MEDIAN,
+ };
+ enum {
+     COMP_NONE = 0,
+     COMP_HUFF,
+ };
+ /*
+  * "Original format" markers.
+  * Based on values gotten from the official VFW encoder.
+  * They are not used during decoding, but they do have
+  * an informative role on seeing what was input
+  * to the encoder.
+  */
+ enum {
+     UTVIDEO_RGB  = MKTAG(0x00, 0x00, 0x01, 0x18),
+     UTVIDEO_RGBA = MKTAG(0x00, 0x00, 0x02, 0x18),
+     UTVIDEO_420  = MKTAG('Y', 'V', '1', '2'),
+     UTVIDEO_422  = MKTAG('Y', 'U', 'Y', '2'),
+ };
+ /* Mapping of libavcodec prediction modes to Ut Video's */
+ extern const int ff_ut_pred_order[5];
+ /* Order of RGB(A) planes in Ut Video */
+ extern const int ff_ut_rgb_order[4];
+ typedef struct UtvideoContext {
+     AVCodecContext *avctx;
+     AVFrame        pic;
+     DSPContext     dsp;
+     uint32_t frame_info_size, flags, frame_info;
+     int      planes;
+     int      slices;
+     int      compression;
+     int      interlaced;
+     int      frame_pred;
+     uint8_t *slice_bits, *slice_buffer;
+     int      slice_bits_size;
+ } UtvideoContext;
+ typedef struct HuffEntry {
+     uint8_t  sym;
+     uint8_t  len;
+     uint32_t code;
+ } HuffEntry;
+ /* Compare huffman tree nodes */
+ int ff_ut_huff_cmp_len(const void *a, const void *b);
+ #endif /* AVCODEC_UTVIDEO_H */
Simple merge
index 0000000,4a82046..1e7c12b
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,735 +1,735 @@@
 - * This file is part of Libav.
+ /*
+  * Ut Video encoder
+  * Copyright (c) 2012 Jan Ekström
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
+  */
+ /**
+  * @file
+  * Ut Video encoder
+  */
+ #include "libavutil/intreadwrite.h"
+ #include "avcodec.h"
+ #include "internal.h"
+ #include "bytestream.h"
+ #include "put_bits.h"
+ #include "dsputil.h"
+ #include "mathops.h"
+ #include "utvideo.h"
+ /* Compare huffentry symbols */
+ static int huff_cmp_sym(const void *a, const void *b)
+ {
+     const HuffEntry *aa = a, *bb = b;
+     return aa->sym - bb->sym;
+ }
+ static av_cold int utvideo_encode_close(AVCodecContext *avctx)
+ {
+     UtvideoContext *c = avctx->priv_data;
+     av_freep(&avctx->coded_frame);
+     av_freep(&c->slice_bits);
+     av_freep(&c->slice_buffer);
+     return 0;
+ }
+ static av_cold int utvideo_encode_init(AVCodecContext *avctx)
+ {
+     UtvideoContext *c = avctx->priv_data;
+     uint32_t original_format;
+     c->avctx           = avctx;
+     c->frame_info_size = 4;
+     switch (avctx->pix_fmt) {
+     case PIX_FMT_RGB24:
+         c->planes        = 3;
+         avctx->codec_tag = MKTAG('U', 'L', 'R', 'G');
+         original_format  = UTVIDEO_RGB;
+         break;
+     case PIX_FMT_RGBA:
+         c->planes        = 4;
+         avctx->codec_tag = MKTAG('U', 'L', 'R', 'A');
+         original_format  = UTVIDEO_RGBA;
+         break;
+     case PIX_FMT_YUV420P:
+         if (avctx->width & 1 || avctx->height & 1) {
+             av_log(avctx, AV_LOG_ERROR,
+                    "4:2:0 video requires even width and height.\n");
+             return AVERROR_INVALIDDATA;
+         }
+         c->planes        = 3;
+         avctx->codec_tag = MKTAG('U', 'L', 'Y', '0');
+         original_format  = UTVIDEO_420;
+         break;
+     case PIX_FMT_YUV422P:
+         if (avctx->width & 1) {
+             av_log(avctx, AV_LOG_ERROR,
+                    "4:2:2 video requires even width.\n");
+             return AVERROR_INVALIDDATA;
+         }
+         c->planes        = 3;
+         avctx->codec_tag = MKTAG('U', 'L', 'Y', '2');
+         original_format  = UTVIDEO_422;
+         break;
+     default:
+         av_log(avctx, AV_LOG_ERROR, "Unknown pixel format: %d\n",
+                avctx->pix_fmt);
+         return AVERROR_INVALIDDATA;
+     }
+     ff_dsputil_init(&c->dsp, avctx);
+     /* Check the prediction method, and error out if unsupported */
+     if (avctx->prediction_method < 0 || avctx->prediction_method > 4) {
+         av_log(avctx, AV_LOG_WARNING,
+                "Prediction method %d is not supported in Ut Video.\n",
+                avctx->prediction_method);
+         return AVERROR_OPTION_NOT_FOUND;
+     }
+     if (avctx->prediction_method == FF_PRED_PLANE) {
+         av_log(avctx, AV_LOG_ERROR,
+                "Plane prediction is not supported in Ut Video.\n");
+         return AVERROR_OPTION_NOT_FOUND;
+     }
+     /* Convert from libavcodec prediction type to Ut Video's */
+     c->frame_pred = ff_ut_pred_order[avctx->prediction_method];
+     if (c->frame_pred == PRED_GRADIENT) {
+         av_log(avctx, AV_LOG_ERROR, "Gradient prediction is not supported.\n");
+         return AVERROR_OPTION_NOT_FOUND;
+     }
+     avctx->coded_frame = avcodec_alloc_frame();
+     if (!avctx->coded_frame) {
+         av_log(avctx, AV_LOG_ERROR, "Could not allocate frame.\n");
+         utvideo_encode_close(avctx);
+         return AVERROR(ENOMEM);
+     }
+     /* extradata size is 4 * 32bit */
+     avctx->extradata_size = 16;
+     avctx->extradata = av_mallocz(avctx->extradata_size +
+                                   FF_INPUT_BUFFER_PADDING_SIZE);
+     if (!avctx->extradata) {
+         av_log(avctx, AV_LOG_ERROR, "Could not allocate extradata.\n");
+         utvideo_encode_close(avctx);
+         return AVERROR(ENOMEM);
+     }
+     c->slice_buffer = av_malloc(avctx->width * avctx->height +
+                                 FF_INPUT_BUFFER_PADDING_SIZE);
+     if (!c->slice_buffer) {
+         av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer 1.\n");
+         utvideo_encode_close(avctx);
+         return AVERROR(ENOMEM);
+     }
+     /*
+      * Set the version of the encoder.
+      * Last byte is "implementation ID", which is
+      * obtained from the creator of the format.
+      * Libavcodec has been assigned with the ID 0xF0.
+      */
+     AV_WB32(avctx->extradata, MKTAG(1, 0, 0, 0xF0));
+     /*
+      * Set the "original format"
+      * Not used for anything during decoding.
+      */
+     AV_WL32(avctx->extradata + 4, original_format);
+     /* Write 4 as the 'frame info size' */
+     AV_WL32(avctx->extradata + 8, c->frame_info_size);
+     /*
+      * Set how many slices are going to be used.
+      * Set one slice for now.
+      */
+     c->slices = 1;
+     /* Set compression mode */
+     c->compression = COMP_HUFF;
+     /*
+      * Set the encoding flags:
+      * - Slice count minus 1
+      * - Interlaced encoding mode flag, set to zero for now.
+      * - Compression mode (none/huff)
+      * And write the flags.
+      */
+     c->flags  = (c->slices - 1) << 24;
+     c->flags |= 0 << 11; // bit field to signal interlaced encoding mode
+     c->flags |= c->compression;
+     AV_WL32(avctx->extradata + 12, c->flags);
+     return 0;
+ }
+ static void mangle_rgb_planes(uint8_t *src, int step, int stride, int width,
+                               int height)
+ {
+     int i, j;
+     uint8_t r, g, b;
+     for (j = 0; j < height; j++) {
+         for (i = 0; i < width * step; i += step) {
+             r = src[i];
+             g = src[i + 1];
+             b = src[i + 2];
+             src[i]     = r - g + 0x80;
+             src[i + 2] = b - g + 0x80;
+         }
+         src += stride;
+     }
+ }
+ /* Write data to a plane, no prediction applied */
+ static void write_plane(uint8_t *src, uint8_t *dst, int step, int stride,
+                         int width, int height)
+ {
+     int i, j;
+     for (j = 0; j < height; j++) {
+         for (i = 0; i < width * step; i += step)
+             *dst++ = src[i];
+         src += stride;
+     }
+ }
+ /* Write data to a plane with left prediction */
+ static void left_predict(uint8_t *src, uint8_t *dst, int step, int stride,
+                          int width, int height)
+ {
+     int i, j;
+     uint8_t prev;
+     prev = 0x80; /* Set the initial value */
+     for (j = 0; j < height; j++) {
+         for (i = 0; i < width * step; i += step) {
+             *dst++ = src[i] - prev;
+             prev   = src[i];
+         }
+         src += stride;
+     }
+ }
+ /* Write data to a plane with median prediction */
+ static void median_predict(uint8_t *src, uint8_t *dst, int step, int stride,
+                            int width, int height)
+ {
+     int i, j;
+     int A, B, C;
+     uint8_t prev;
+     /* First line uses left neighbour prediction */
+     prev = 0x80; /* Set the initial value */
+     for (i = 0; i < width * step; i += step) {
+         *dst++ = src[i] - prev;
+         prev   = src[i];
+     }
+     if (height == 1)
+         return;
+     src += stride;
+     /*
+      * Second line uses top prediction for the first sample,
+      * and median for the rest.
+      */
+     C      = src[-stride];
+     *dst++ = src[0] - C;
+     A      = src[0];
+     for (i = step; i < width * step; i += step) {
+         B       = src[i - stride];
+         *dst++  = src[i] - mid_pred(A, B, (A + B - C) & 0xFF);
+         C       = B;
+         A       = src[i];
+     }
+     src += stride;
+     /* Rest of the coded part uses median prediction */
+     for (j = 2; j < height; j++) {
+         for (i = 0; i < width * step; i += step) {
+             B       = src[i - stride];
+             *dst++  = src[i] - mid_pred(A, B, (A + B - C) & 0xFF);
+             C       = B;
+             A       = src[i];
+         }
+         src += stride;
+     }
+ }
+ /* Count the usage of values in a plane */
+ static void count_usage(uint8_t *src, int width,
+                         int height, uint32_t *counts)
+ {
+     int i, j;
+     for (j = 0; j < height; j++) {
+         for (i = 0; i < width; i++) {
+             counts[src[i]]++;
+         }
+         src += width;
+     }
+ }
+ static uint32_t add_weights(uint32_t w1, uint32_t w2)
+ {
+     uint32_t max = (w1 & 0xFF) > (w2 & 0xFF) ? (w1 & 0xFF) : (w2 & 0xFF);
+     return ((w1 & 0xFFFFFF00) + (w2 & 0xFFFFFF00)) | (1 + max);
+ }
+ static void up_heap(uint32_t val, uint32_t *heap, uint32_t *weights)
+ {
+     uint32_t initial_val = heap[val];
+     while (weights[initial_val] < weights[heap[val >> 1]]) {
+         heap[val] = heap[val >> 1];
+         val     >>= 1;
+     }
+     heap[val] = initial_val;
+ }
+ static void down_heap(uint32_t nr_heap, uint32_t *heap, uint32_t *weights)
+ {
+     uint32_t val = 1;
+     uint32_t val2;
+     uint32_t initial_val = heap[val];
+     while (1) {
+         val2 = val << 1;
+         if (val2 > nr_heap)
+             break;
+         if (val2 < nr_heap && weights[heap[val2 + 1]] < weights[heap[val2]])
+             val2++;
+         if (weights[initial_val] < weights[heap[val2]])
+             break;
+         heap[val] = heap[val2];
+         val = val2;
+     }
+     heap[val] = initial_val;
+ }
+ /* Calculate the huffman code lengths from value counts */
+ static void calculate_code_lengths(uint8_t *lengths, uint32_t *counts)
+ {
+     uint32_t nr_nodes, nr_heap, node1, node2;
+     int      i, j;
+     int32_t  k;
+     /* Heap and node entries start from 1 */
+     uint32_t weights[512];
+     uint32_t heap[512];
+     int32_t  parents[512];
+     /* Set initial weights */
+     for (i = 0; i < 256; i++)
+         weights[i + 1] = (counts[i] ? counts[i] : 1) << 8;
+     nr_nodes = 256;
+     nr_heap  = 0;
+     heap[0]    = 0;
+     weights[0] = 0;
+     parents[0] = -2;
+     /* Create initial nodes */
+     for (i = 1; i <= 256; i++) {
+         parents[i] = -1;
+         heap[++nr_heap] = i;
+         up_heap(nr_heap, heap, weights);
+     }
+     /* Build the tree */
+     while (nr_heap > 1) {
+         node1   = heap[1];
+         heap[1] = heap[nr_heap--];
+         down_heap(nr_heap, heap, weights);
+         node2   = heap[1];
+         heap[1] = heap[nr_heap--];
+         down_heap(nr_heap, heap, weights);
+         nr_nodes++;
+         parents[node1]    = parents[node2] = nr_nodes;
+         weights[nr_nodes] = add_weights(weights[node1], weights[node2]);
+         parents[nr_nodes] = -1;
+         heap[++nr_heap] = nr_nodes;
+         up_heap(nr_heap, heap, weights);
+     }
+     /* Generate lengths */
+     for (i = 1; i <= 256; i++) {
+         j = 0;
+         k = i;
+         while (parents[k] >= 0) {
+             k = parents[k];
+             j++;
+         }
+         lengths[i - 1] = j;
+     }
+ }
+ /* Calculate the actual huffman codes from the code lengths */
+ static void calculate_codes(HuffEntry *he)
+ {
+     int last, i;
+     uint32_t code;
+     qsort(he, 256, sizeof(*he), ff_ut_huff_cmp_len);
+     last = 255;
+     while (he[last].len == 255 && last)
+         last--;
+     code = 1;
+     for (i = last; i >= 0; i--) {
+         he[i].code  = code >> (32 - he[i].len);
+         code       += 0x80000000u >> (he[i].len - 1);
+     }
+     qsort(he, 256, sizeof(*he), huff_cmp_sym);
+ }
+ /* Write huffman bit codes to a memory block */
+ static int write_huff_codes(uint8_t *src, uint8_t *dst, int dst_size,
+                             int width, int height, HuffEntry *he)
+ {
+     PutBitContext pb;
+     int i, j;
+     int count;
+     init_put_bits(&pb, dst, dst_size);
+     /* Write the codes */
+     for (j = 0; j < height; j++) {
+         for (i = 0; i < width; i++)
+             put_bits(&pb, he[src[i]].len, he[src[i]].code);
+         src += width;
+     }
+     /* Pad output to a 32bit boundary */
+     count = put_bits_count(&pb) & 0x1F;
+     if (count)
+         put_bits(&pb, 32 - count, 0);
+     /* Get the amount of bits written */
+     count = put_bits_count(&pb);
+     /* Flush the rest with zeroes */
+     flush_put_bits(&pb);
+     return count;
+ }
+ static int encode_plane(AVCodecContext *avctx, uint8_t *src,
+                         uint8_t *dst, int step, int stride,
+                         int width, int height, PutByteContext *pb)
+ {
+     UtvideoContext *c        = avctx->priv_data;
+     uint8_t  lengths[256];
+     uint32_t counts[256]     = { 0 };
+     HuffEntry he[256];
+     uint32_t offset = 0, slice_len = 0;
+     int      i, sstart, send = 0;
+     int      symbol;
+     /* Do prediction / make planes */
+     switch (c->frame_pred) {
+     case PRED_NONE:
+         for (i = 0; i < c->slices; i++) {
+             sstart = send;
+             send   = height * (i + 1) / c->slices;
+             write_plane(src + sstart * stride, dst + sstart * width,
+                         step, stride, width, send - sstart);
+         }
+         break;
+     case PRED_LEFT:
+         for (i = 0; i < c->slices; i++) {
+             sstart = send;
+             send   = height * (i + 1) / c->slices;
+             left_predict(src + sstart * stride, dst + sstart * width,
+                          step, stride, width, send - sstart);
+         }
+         break;
+     case PRED_MEDIAN:
+         for (i = 0; i < c->slices; i++) {
+             sstart = send;
+             send   = height * (i + 1) / c->slices;
+             median_predict(src + sstart * stride, dst + sstart * width,
+                            step, stride, width, send - sstart);
+         }
+         break;
+     default:
+         av_log(avctx, AV_LOG_ERROR, "Unknown prediction mode: %d\n",
+                c->frame_pred);
+         return AVERROR_OPTION_NOT_FOUND;
+     }
+     /* Count the usage of values */
+     count_usage(dst, width, height, counts);
+     /* Check for a special case where only one symbol was used */
+     for (symbol = 0; symbol < 256; symbol++) {
+         /* If non-zero count is found, see if it matches width * height */
+         if (counts[symbol]) {
+             /* Special case if only one symbol was used */
+             if (counts[symbol] == width * height) {
+                 /*
+                  * Write a zero for the single symbol
+                  * used in the plane, else 0xFF.
+                  */
+                 for (i = 0; i < 256; i++) {
+                     if (i == symbol)
+                         bytestream2_put_byte(pb, 0);
+                     else
+                         bytestream2_put_byte(pb, 0xFF);
+                 }
+                 /* Write zeroes for lengths */
+                 for (i = 0; i < c->slices; i++)
+                     bytestream2_put_le32(pb, 0);
+                 /* And that's all for that plane folks */
+                 return 0;
+             }
+             break;
+         }
+     }
+     /* Calculate huffman lengths */
+     calculate_code_lengths(lengths, counts);
+     /*
+      * Write the plane's header into the output packet:
+      * - huffman code lengths (256 bytes)
+      * - slice end offsets (gotten from the slice lengths)
+      */
+     for (i = 0; i < 256; i++) {
+         bytestream2_put_byte(pb, lengths[i]);
+         he[i].len = lengths[i];
+         he[i].sym = i;
+     }
+     /* Calculate the huffman codes themselves */
+     calculate_codes(he);
+     send = 0;
+     for (i = 0; i < c->slices; i++) {
+         sstart  = send;
+         send    = height * (i + 1) / c->slices;
+         /*
+          * Write the huffman codes to a buffer,
+          * get the offset in bits and convert to bytes.
+          */
+         offset += write_huff_codes(dst + sstart * width, c->slice_bits,
+                                    width * (send - sstart), width,
+                                    send - sstart, he) >> 3;
+         slice_len = offset - slice_len;
+         /* Byteswap the written huffman codes */
+         c->dsp.bswap_buf((uint32_t *) c->slice_bits,
+                          (uint32_t *) c->slice_bits,
+                          slice_len >> 2);
+         /* Write the offset to the stream */
+         bytestream2_put_le32(pb, offset);
+         /* Seek to the data part of the packet */
+         bytestream2_seek_p(pb, 4 * (c->slices - i - 1) +
+                            offset - slice_len, SEEK_CUR);
+         /* Write the slices' data into the output packet */
+         bytestream2_put_buffer(pb, c->slice_bits, slice_len);
+         /* Seek back to the slice offsets */
+         bytestream2_seek_p(pb, -4 * (c->slices - i - 1) - offset,
+                            SEEK_CUR);
+         slice_len = offset;
+     }
+     /* And at the end seek to the end of written slice(s) */
+     bytestream2_seek_p(pb, offset, SEEK_CUR);
+     return 0;
+ }
+ static int utvideo_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
+                                 const AVFrame *pic, int *got_packet)
+ {
+     UtvideoContext *c = avctx->priv_data;
+     PutByteContext pb;
+     uint32_t frame_info;
+     uint8_t *dst;
+     int width = avctx->width, height = avctx->height;
+     int i, ret = 0;
+     /* Allocate a new packet if needed, and set it to the pointer dst */
+     ret = ff_alloc_packet(pkt, (256 + 4 * c->slices + width * height) *
+                           c->planes + 4);
+     if (ret < 0) {
+         av_log(avctx, AV_LOG_ERROR,
+                "Error allocating the output packet, or the provided packet "
+                "was too small.\n");
+         return ret;
+     }
+     dst = pkt->data;
+     bytestream2_init_writer(&pb, dst, pkt->size);
+     av_fast_malloc(&c->slice_bits, &c->slice_bits_size,
+                    width * height + FF_INPUT_BUFFER_PADDING_SIZE);
+     if (!c->slice_bits) {
+         av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer 2.\n");
+         return AVERROR(ENOMEM);
+     }
+     /* In case of RGB, mangle the planes to Ut Video's format */
+     if (avctx->pix_fmt == PIX_FMT_RGBA || avctx->pix_fmt == PIX_FMT_RGB24)
+         mangle_rgb_planes(pic->data[0], c->planes, pic->linesize[0], width,
+                           height);
+     /* Deal with the planes */
+     switch (avctx->pix_fmt) {
+     case PIX_FMT_RGB24:
+     case PIX_FMT_RGBA:
+         for (i = 0; i < c->planes; i++) {
+             ret = encode_plane(avctx, pic->data[0] + ff_ut_rgb_order[i],
+                                c->slice_buffer, c->planes, pic->linesize[0],
+                                width, height, &pb);
+             if (ret) {
+                 av_log(avctx, AV_LOG_ERROR, "Error encoding plane %d.\n", i);
+                 return ret;
+             }
+         }
+         break;
+     case PIX_FMT_YUV422P:
+         for (i = 0; i < c->planes; i++) {
+             ret = encode_plane(avctx, pic->data[i], c->slice_buffer, 1,
+                                pic->linesize[i], width >> !!i, height, &pb);
+             if (ret) {
+                 av_log(avctx, AV_LOG_ERROR, "Error encoding plane %d.\n", i);
+                 return ret;
+             }
+         }
+         break;
+     case PIX_FMT_YUV420P:
+         for (i = 0; i < c->planes; i++) {
+             ret = encode_plane(avctx, pic->data[i], c->slice_buffer, 1,
+                                pic->linesize[i], width >> !!i, height >> !!i,
+                                &pb);
+             if (ret) {
+                 av_log(avctx, AV_LOG_ERROR, "Error encoding plane %d.\n", i);
+                 return ret;
+             }
+         }
+         break;
+     default:
+         av_log(avctx, AV_LOG_ERROR, "Unknown pixel format: %d\n",
+                avctx->pix_fmt);
+         return AVERROR_INVALIDDATA;
+     }
+     /*
+      * Write frame information (LE 32bit unsigned)
+      * into the output packet.
+      * Contains the prediction method.
+      */
+     frame_info = c->frame_pred << 8;
+     bytestream2_put_le32(&pb, frame_info);
+     /*
+      * At least currently Ut Video is IDR only.
+      * Set flags accordingly.
+      */
+     avctx->coded_frame->reference = 0;
+     avctx->coded_frame->key_frame = 1;
+     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
+     pkt->size   = bytestream2_tell_p(&pb);
+     pkt->flags |= AV_PKT_FLAG_KEY;
+     /* Packet should be done */
+     *got_packet = 1;
+     return 0;
+ }
+ AVCodec ff_utvideo_encoder = {
+     .name           = "utvideo",
+     .type           = AVMEDIA_TYPE_VIDEO,
+     .id             = CODEC_ID_UTVIDEO,
+     .priv_data_size = sizeof(UtvideoContext),
+     .init           = utvideo_encode_init,
+     .encode2        = utvideo_encode_frame,
+     .close          = utvideo_encode_close,
+     .pix_fmts       = (const enum PixelFormat[]) {
+                           PIX_FMT_RGB24, PIX_FMT_RGBA, PIX_FMT_YUV422P,
+                           PIX_FMT_YUV420P, PIX_FMT_NONE
+                       },
+     .long_name      = NULL_IF_CONFIG_SMALL("Ut Video"),
+ };
@@@ -27,8 -27,8 +27,8 @@@
   */
  
  #define LIBAVCODEC_VERSION_MAJOR 54
- #define LIBAVCODEC_VERSION_MINOR 53
 -#define LIBAVCODEC_VERSION_MINOR 26
 -#define LIBAVCODEC_VERSION_MICRO  0
++#define LIBAVCODEC_VERSION_MINOR 54
 +#define LIBAVCODEC_VERSION_MICRO 100
  
  #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                 LIBAVCODEC_VERSION_MINOR, \
index 0000000,3fe834f..f8ec611
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,51 +1,51 @@@
 -0,          0,          0,        1,    91796, 4c8297f7f28046125c690222c3214896
 -0,          1,          1,        1,    92148, ba8df4e34baa5679735980d32ab4dcbb
 -0,          2,          2,        1,    93280, 82eebd80efb688a5da6779237895a254
 -0,          3,          3,        1,    91620, 481fe4261a0dcdc7179753c786425a0e
 -0,          4,          4,        1,    90468, 8fe1fde928524130efd2adb3e5dbfc14
 -0,          5,          5,        1,    92192, 937ccb039db2a25448c3bf4f7d8dcc82
 -0,          6,          6,        1,    92208, 07f66e4f355f84c3a1ed85add165bda1
 -0,          7,          7,        1,    91880, 7a680775a71c0db8a7b06545d489a016
 -0,          8,          8,        1,    91964, 8c91d9908ec476e6457155fbbc20551a
 -0,          9,          9,        1,    92320, 99577a047b9b6c9d18370c636e093cb9
 -0,         10,         10,        1,    92316, 6ee62076a75b457c358aa3da45638c6c
 -0,         11,         11,        1,    92284, 6c82d57786e0e1010944e6a1c535252e
 -0,         12,         12,        1,    90932, 0e5bb1fd031143e8001852bd42a2d708
 -0,         13,         13,        1,    91620, c590080aebc74c4d64090161a43146b5
 -0,         14,         14,        1,    93124, 4bf756daa31db1a64148ace4e8ec8a17
 -0,         15,         15,        1,    93152, d9b9edf360b36ac3f54bfd835596294f
 -0,         16,         16,        1,    92088, efd7436e924eacb2177021bd6b676410
 -0,         17,         17,        1,    91828, d8434dd3ceb3fb8026e380cec20aeda7
 -0,         18,         18,        1,    91216, c546d8e3a45395f8037280750dc344fd
 -0,         19,         19,        1,    90892, 9912d9aaf53dc505cf0be17a4013e893
 -0,         20,         20,        1,    90416, fecb67be6f80a2c368c3e0c864033363
 -0,         21,         21,        1,    90288, 9a32f067364f8ac7d145826e5b1af157
 -0,         22,         22,        1,    90824, 4feb2146c84616ac093a21805961896c
 -0,         23,         23,        1,    91592, 57f7ca368fd6e578d19a95e4270b932b
 -0,         24,         24,        1,    92692, 71da3aa27ac6abdbef33c933b3ada49e
 -0,         25,         25,        1,    91588, 21b36844ab555ca2c8565b16a6cd3cda
 -0,         26,         26,        1,    90940, c0d4e047f4bcb7741dda13dc093f1ff7
 -0,         27,         27,        1,    90548, 61e91e2723e3d402efd4166a8d537799
 -0,         28,         28,        1,    88380, 142ca8a9b848583906a6872559f6afe4
 -0,         29,         29,        1,    88412, 12ed09ec8ab4b0c933f306eab12bbb2e
 -0,         30,         30,        1,    89856, b12d495e747e44c624f2f1b54da68488
 -0,         31,         31,        1,    90764, 6593de0da477a1acef29231046c4e036
 -0,         32,         32,        1,    91328, 305797e1e5cd779192e71d0c7c62d590
 -0,         33,         33,        1,    93216, 560d8fd4f3ed691c7a32243412156eae
 -0,         34,         34,        1,    92044, fee3c383804680b4d7b4516ccd399c70
 -0,         35,         35,        1,    91148, 78683ab3ed20af28d7a70a6ec46cb51b
 -0,         36,         36,        1,    90376, 9c42b34763c52af7d4bedbf7f4188c26
 -0,         37,         37,        1,    90632, a5796dd685a695292fa324565dfd5475
 -0,         38,         38,        1,    89844, 0c05fd10b989657cf6cb6142dada5dc9
 -0,         39,         39,        1,    89808, 0524cf03f546d2694cf3743d27da6b85
 -0,         40,         40,        1,    88900, 0e45ddf73bf25ba03b3ddf4c8fcbe710
 -0,         41,         41,        1,    90584, 4af285ba46599e268926613f23cffea9
 -0,         42,         42,        1,    90560, c94bfa84bf549464025aef51c3084abb
 -0,         43,         43,        1,    90424, c3abba4ca926d22094b58fb3c87d301f
 -0,         44,         44,        1,    89796, f765800cb70f5601481077442e5e8255
 -0,         45,         45,        1,    88132, 0670d35d34a3fd6926dd3c5771f8929a
 -0,         46,         46,        1,    87176, 0068a72ac885f81a37e65b0a9c460d26
 -0,         47,         47,        1,    87644, 999cd5da8ac0bceb83132ea027ef998e
 -0,         48,         48,        1,    87712, b7f38fb617599a6fbb7304790e7a8249
 -0,         49,         49,        1,    86632, fce71c4a72c805cbfe08dbf187f20c5a
+ #tb 0: 1/25
++0,          0,          0,        1,    93168, 083b68ac10646d425382cd3aed5d0ef0
++0,          1,          1,        1,    93400, f8d2b0fed320270c980140d187d01a25
++0,          2,          2,        1,    94536, f66ff5cccd63a468feb84aa22dae1c7c
++0,          3,          3,        1,    92928, 255ea0d934558adc2e2637bddb1284cf
++0,          4,          4,        1,    91800, 864d823c5885003e72f41a869c74d769
++0,          5,          5,        1,    93468, c6bfb70c03a7cfb4ec09acf2d7ec4f91
++0,          6,          6,        1,    93460, 6a5834ca48a2707e456d8c9c67b2cebb
++0,          7,          7,        1,    93132, 2c3968dc6af9917bee1846e1c85c5e99
++0,          8,          8,        1,    93252, a6739a7d07fd86f135c79e271da1789c
++0,          9,          9,        1,    93580, 8b587ed5fc102e2a0fff55674b1ada23
++0,         10,         10,        1,    93548, 4a87d1f0f5a1c3047aa77fc6d10cb6d1
++0,         11,         11,        1,    93520, 520bfaebdf5d972dae3671626374bed4
++0,         12,         12,        1,    92168, cc7c57ef93047aa13cf3fc5872564563
++0,         13,         13,        1,    92860, 8851d9930079a406d9cba89ce00a7feb
++0,         14,         14,        1,    94380, 2eb1d9ef63a0e74487f36f3e97bdf291
++0,         15,         15,        1,    94392, 2c9e589c3ccece6541193b7e61bf28d9
++0,         16,         16,        1,    93360, e138b833f6af0d0e189e8c3879af4cdd
++0,         17,         17,        1,    93108, 597e4c457845667e553c96b02acc40c3
++0,         18,         18,        1,    92568, 1623855c558e4b779bada7149adcb752
++0,         19,         19,        1,    92232, 78666f67c9b6eeff682f5ebf2e2b5145
++0,         20,         20,        1,    91696, aba549ebc0337df1aa5708cde9c4650d
++0,         21,         21,        1,    91688, cc7b65f321a50e117168b0be6a2c4a0f
++0,         22,         22,        1,    92164, 29b235028ca0bf6d9b752069529e2105
++0,         23,         23,        1,    92812, a23ca4b1b02965afc8cddf4b6022e9c1
++0,         24,         24,        1,    93960, afc0e5e4d45f9af68555cfff9e7f2e5d
++0,         25,         25,        1,    92892, 16d1afc5c8aa8b3b55e52e91e5baed53
++0,         26,         26,        1,    92248, a4dd3afd173d419eaec5f9632e64da0f
++0,         27,         27,        1,    91864, 614063fe03b92352d05d746dcabbbd10
++0,         28,         28,        1,    89756, 5a963cfeabc03d1409533bf2e5dd700b
++0,         29,         29,        1,    89812, f4fea21c34be3e85ba0790ef1e992214
++0,         30,         30,        1,    91184, 7aaad112ebb7fa15612fa63c8b313f80
++0,         31,         31,        1,    92076, de3c4aefe9c84b73b9c9494c09a0b22c
++0,         32,         32,        1,    92532, 4f445ee8eeaf323a9ff012a05ca1d3e2
++0,         33,         33,        1,    94572, 00cd8ab5abe5faa6cf59e54f3871a242
++0,         34,         34,        1,    93368, a303dd519e8ff023f488e4e2ee33e256
++0,         35,         35,        1,    92420, efce365314ac4d9e40959de0fc6fc01b
++0,         36,         36,        1,    91696, bb00659a54d8ded77615403962765238
++0,         37,         37,        1,    91912, b0e97a8ef2c73cd3d3b6a2d0bf08a1df
++0,         38,         38,        1,    91080, ff5e3be417b46de0bd9af03fb0ac7429
++0,         39,         39,        1,    91124, 9bca613b7f5a6543b63ad15c2198c037
++0,         40,         40,        1,    90188, 89b0ca054eead42930b946f7199b4fba
++0,         41,         41,        1,    91888, eda5dc80817de04c2528872e773bf3a9
++0,         42,         42,        1,    91832, eaea94320b6a85179a63b6330663d439
++0,         43,         43,        1,    91760, 412fca7fd02727857d4440cec3d4c0df
++0,         44,         44,        1,    91108, 9718c1bf512ee2be617bbc526211e8e0
++0,         45,         45,        1,    89544, b225acdf63a0183d00cd1f04ec0e49c9
++0,         46,         46,        1,    88544, 4ed88cdc92c56f872e5e696fb4da6f0d
++0,         47,         47,        1,    88960, 8b907526f25008a30e5c333867a21f54
++0,         48,         48,        1,    89068, 3bc4c3f7cb75befba57895b6c9e1d64e
++0,         49,         49,        1,    88012, 90132fa682959e1e3a1484b174cb2041
index 0000000,ade2923..9981e06
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,51 +1,51 @@@
 -0,          0,          0,        1,    89780, 3e91243736f0d8c96ec01e53e1a0ca1a
 -0,          1,          1,        1,    89692, 29e8beef70f920150f3405328130c1f4
 -0,          2,          2,        1,    90912, 8ef86647ae9006cb888248b346091603
 -0,          3,          3,        1,    89568, 9af0abff68a9e66adf177e626c88477d
 -0,          4,          4,        1,    88552, 7149af41c6213afb224d5e483b6a0771
 -0,          5,          5,        1,    90188, 7a8818cdf4c5cfb961a84e6f0affb333
 -0,          6,          6,        1,    90220, 10a59f9d437355a7cfcc87800ad58f55
 -0,          7,          7,        1,    89432, e7ade031b0cfe8ba5720ca82c0b5134a
 -0,          8,          8,        1,    89892, 21b4ae6db7817caec958caa6d993d08e
 -0,          9,          9,        1,    90404, 90fda92c74b423705233620283ff11b0
 -0,         10,         10,        1,    90028, efa74c6cea3e5b4795a570e4ecec8359
 -0,         11,         11,        1,    90056, ac9426560a82c563184be68c9a044245
 -0,         12,         12,        1,    89116, 523dfd6c2d8732b4c709270648bd3fc6
 -0,         13,         13,        1,    89820, d6829b4ac96790f3b38d54465afc281c
 -0,         14,         14,        1,    90720, b2d2130e5a677a292c6ac5ee715fb08b
 -0,         15,         15,        1,    90900, fd63286afaa80474c069910091c48d82
 -0,         16,         16,        1,    89892, dce4344b86b6f6452da8e5c582817bbb
 -0,         17,         17,        1,    89896, b4b4afffba0a9b93b8677695b0246096
 -0,         18,         18,        1,    89172, c842bcea2ae28737b696b7066f032c21
 -0,         19,         19,        1,    88920, a90e2a3326ad821a972ed5663e4db3dd
 -0,         20,         20,        1,    88380, f6e80319224d2d1164f8c92465434d83
 -0,         21,         21,        1,    88508, 5338f8602eb21ec8c98f9a94c614c6ae
 -0,         22,         22,        1,    88636, b5342f8831e4c75755097230ea56caf4
 -0,         23,         23,        1,    89764, 6cdfe5b2789b960cd24592f0d4c8e450
 -0,         24,         24,        1,    90252, 317353d115124d89d7648b9381221fe9
 -0,         25,         25,        1,    89500, add22cae4aaec687340ad45cf7adfd1a
 -0,         26,         26,        1,    89036, 0a2b14e5ceec26f9498d1caea1767870
 -0,         27,         27,        1,    88676, b0978d633f9f1aacbf1bfd1a779e654a
 -0,         28,         28,        1,    87092, a5aed642ca45d403a89b12d9405128e1
 -0,         29,         29,        1,    87168, bbf30ee8918be97766c50219886b2045
 -0,         30,         30,        1,    88084, 5913cbc1c3adebb6f9f230b24f3a3eee
 -0,         31,         31,        1,    89056, 9f86fd1126923de5bbcf57b3e4c19824
 -0,         32,         32,        1,    89372, fb6b14b16c900523dad7c8be2969776e
 -0,         33,         33,        1,    90372, 7c95a49abadaa5914d71a3b8ccd069fc
 -0,         34,         34,        1,    89732, 7d7ad876e67daa9aafa88e5117c5db2a
 -0,         35,         35,        1,    89264, c546830ac81b57f4284fd9567687adbf
 -0,         36,         36,        1,    88692, 640a270b1c421f5864264a22c4dcef61
 -0,         37,         37,        1,    89044, b46a8cdedadd85dadc999bb71e9c9a1b
 -0,         38,         38,        1,    88672, 5a906c0ecf4d818fe8baccbaa0fd306e
 -0,         39,         39,        1,    88492, 80ce9360ac56c79cce311392db8fcf76
 -0,         40,         40,        1,    87372, 34e03634ebdf41d5faeb93a8322feec5
 -0,         41,         41,        1,    88896, edff2238d908325809b07b542b6f95d7
 -0,         42,         42,        1,    88604, 575ac8566e144c94c5c09cbaae333262
 -0,         43,         43,        1,    88424, a42e08d0624a5fbb91aee7c1030c442c
 -0,         44,         44,        1,    87932, eee99a04e2934a541a6bad33ccd64c38
 -0,         45,         45,        1,    86916, 37ba014aa01c2cf100e719e67bec00c1
 -0,         46,         46,        1,    86316, e5b94ffcb55d82d2fd5a3a31084b00fe
 -0,         47,         47,        1,    86428, 96cea3d74a0c8ff2702ca2bbccf9ec6e
 -0,         48,         48,        1,    86228, 1390793cf7369b808abfefb53affb800
 -0,         49,         49,        1,    85284, 89d0772c948e95af1f78ae2a0dd341c8
+ #tb 0: 1/25
++0,          0,          0,        1,    90796, f90f29632eceac669132286385798866
++0,          1,          1,        1,    90652, 62890a83da5b9226ff197a0508d0db21
++0,          2,          2,        1,    91856, 815baaed2e42f9bf201f0b4630f265b9
++0,          3,          3,        1,    90572, 5e94b63fea1cb60f32f66a23ea97ea4d
++0,          4,          4,        1,    89580, ec8d444349c59dfbafd57095d0cab03a
++0,          5,          5,        1,    91148, 51be2db33b11859938c3162b02d2b183
++0,          6,          6,        1,    91212, 32df9c063904005a6c5a3a91b2e57b0d
++0,          7,          7,        1,    90376, 9959a40ad11a0a7e6f98a3bb2e1842cd
++0,          8,          8,        1,    90856, d03fa2bf67361ae27167ca61e0fa37da
++0,          9,          9,        1,    91356, ea2b8edf132d0492d6241f655a291a0c
++0,         10,         10,        1,    91032, 6204ddfa158037ee362920176597d85e
++0,         11,         11,        1,    91004, d210d0cc04e423e59fac9aaaf9bf01bd
++0,         12,         12,        1,    90096, 615dbf6c64f6165902a25970d226feb8
++0,         13,         13,        1,    90832, 66858d96fdb0dc8d89f1902591ccc886
++0,         14,         14,        1,    91688, 34a7ad1554020c4c78319803b41281d9
++0,         15,         15,        1,    91796, fd7cb3faaab8ca700dd0854915f72bb0
++0,         16,         16,        1,    90836, 983958df5d66c85194c2e2e7b27cf91b
++0,         17,         17,        1,    90848, 09d8051c04533059768b75967509c752
++0,         18,         18,        1,    90088, cf3fb73f2382063aa76bcdbe00739a9f
++0,         19,         19,        1,    89892, e6c2ec30ea12db29eedd649aa9a62476
++0,         20,         20,        1,    89304, 19603c655f5445bd4dadd4b88e482096
++0,         21,         21,        1,    89560, 0e842bf72ce795b37dcd588874913d2b
++0,         22,         22,        1,    89604, 83320a47a9882645aee67e8d343aee07
++0,         23,         23,        1,    90684, c45b3a01ab736a363f4771a277d3bf37
++0,         24,         24,        1,    91224, dbaf3f033273748bba13bc3332f399d5
++0,         25,         25,        1,    90480, de5b49620f1242f24250721dab315f71
++0,         26,         26,        1,    89988, a0d8ff14f468c5281c7bb80524743cbc
++0,         27,         27,        1,    89636, 68ca298fa61d18c963c0b9610dfb48bf
++0,         28,         28,        1,    88168, 22128400447fe0fcc9f067e1430e462e
++0,         29,         29,        1,    88188, 0816840bbd1b2857e99973a69e65c26a
++0,         30,         30,        1,    89068, bcf924eea0f45a9eeb01a886a154d969
++0,         31,         31,        1,    90104, 1b19dd4e4ed22e56b707f63f559174c6
++0,         32,         32,        1,    90344, 0142df8c6dfb99108622e8e7c8ebfd6d
++0,         33,         33,        1,    91348, 031e49bf9dc9e2c9ac6a86ab5bdba307
++0,         34,         34,        1,    90740, 5d4428cb9a61a57bfa724e0aea500db1
++0,         35,         35,        1,    90204, ad8a5494a7145e13aa3eb811f0af5843
++0,         36,         36,        1,    89708, 2421d07a9ed208f993d92c7d1f9c3fac
++0,         37,         37,        1,    90036, c4edb940ea1f10b716100fde23a5cb08
++0,         38,         38,        1,    89560, f6ba26af186ee1c7189603e6335281a8
++0,         39,         39,        1,    89464, aa77758a59ab9a7a3952dd9456040a5d
++0,         40,         40,        1,    88380, 78cd903ba608c770aeec39f13bd44896
++0,         41,         41,        1,    89872, 21e9e482d36a30bbff9ad897a2bda3f4
++0,         42,         42,        1,    89504, 9149a892a42e065079d614fba1e367c8
++0,         43,         43,        1,    89408, b5ed6ff8f7682a71ca2ca2bca5b1dbc0
++0,         44,         44,        1,    88916, 712d9669ad046b3993371cfb618c934e
++0,         45,         45,        1,    87948, 47c9bfa99221085efffe30e7b335beaa
++0,         46,         46,        1,    87284, 821cc4427f2649322950116caad44e96
++0,         47,         47,        1,    87424, 0d072e86818957bc3c40ffeb090dbcd8
++0,         48,         48,        1,    87296, 05bfe7d720b225ffc6b09a4ddf6ffa36
++0,         49,         49,        1,    86416, 85df53da921ba046d8e1d07349819236
index 0000000,69c4b65..e926f53
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,51 +1,51 @@@
 -0,          0,          0,        1,   191804, f2daaab85ecc8227c958e44b3456fae8
 -0,          1,          1,        1,   191828, 80c599b8f3c58db35f181059aec90869
 -0,          2,          2,        1,   191672, 081ab347067e368c3e92ac1faa2ea933
 -0,          3,          3,        1,   191700, 198425dac62730270553fef97ac3ef38
 -0,          4,          4,        1,   191976, a667de6623f7d11b7f7d9fe40abd578e
 -0,          5,          5,        1,   191764, 1ba21a4be3b534b6a651640bf12b63cf
 -0,          6,          6,        1,   191720, 9d63ddee2324fc96727607c5980709f9
 -0,          7,          7,        1,   191692, b86bfa6ecfeee06775495a170a7c8bb9
 -0,          8,          8,        1,   191584, a86a64a1d383ef072f2fc17e7976d048
 -0,          9,          9,        1,   191556, 8faea41b0af5ab445eb65f34727d0cfa
 -0,         10,         10,        1,   191476, e20631164f65ad55642216c8cdfb414c
 -0,         11,         11,        1,   191280, daf024a253a90b8b6f59b570ca63356e
 -0,         12,         12,        1,   191700, fae65d15784413cbc36c6e06f9f3d868
 -0,         13,         13,        1,   191432, aa799f4516b2e48e706da61e5a8fc1f3
 -0,         14,         14,        1,   191420, 61d1e5031a2b5e6819c8531aa34fe4c1
 -0,         15,         15,        1,   191416, f3e1e60fb59f4e9f1d9e98c0eee42c3c
 -0,         16,         16,        1,   191504, 2aae6896ded24fb31898249ea0d99355
 -0,         17,         17,        1,   191592, 1d48065c7e445284b8bd49f4fbe20668
 -0,         18,         18,        1,   191612, 37ffbf09c3f44f4b954253627453bd3a
 -0,         19,         19,        1,   191624, fa479dd1f2a412115d95bb8389f61be8
 -0,         20,         20,        1,   191600, 4642ec6004690fbeb3c28a41198faeb3
 -0,         21,         21,        1,   191664, 4ffff6d4daba3a27c0493826b4777b59
 -0,         22,         22,        1,   191544, 9ba114162c29f537783770c2968cba9a
 -0,         23,         23,        1,   191584, 56fa5cef18ff2b91677183e4063d94b7
 -0,         24,         24,        1,   191648, 854aa515d70326a6e6230403f6e46cd8
 -0,         25,         25,        1,   191528, 56a8493b14f553ea72d15414b349032c
 -0,         26,         26,        1,   191644, 89a2e45e7c9a679a532054bfa4c621ce
 -0,         27,         27,        1,   191808, 6a09e77d1581dd82b5013f05e32cffe9
 -0,         28,         28,        1,   192036, 4375e948a177a7d9242e521671c6083f
 -0,         29,         29,        1,   191968, ec50a1d34a2cd973510bc5059137dc0a
 -0,         30,         30,        1,   191740, c0c96ae654189fb0db4862584d102db8
 -0,         31,         31,        1,   191792, 7243b58b1a72213ad95230f5ac8bbe72
 -0,         32,         32,        1,   191636, ae0e180bd5f1b79cf2862865e5a5b89e
 -0,         33,         33,        1,   191408, 85f18294eef023a0ff995fd75d22da47
 -0,         34,         34,        1,   191332, ff1c7c120d5f10027ff8e07fef2ca459
 -0,         35,         35,        1,   191552, 36dd28b3ed917e1a9dd460fbafccbd42
 -0,         36,         36,        1,   191860, c864fe9b3ed74afc68d1206b3be60717
 -0,         37,         37,        1,   191832, 3135be8c92e17e8dfbe713f2119407a8
 -0,         38,         38,        1,   191816, 1a19ec6f037aecd3523879a071dd6b7d
 -0,         39,         39,        1,   191708, ff5394fbaf21e31025ccb71189274d67
 -0,         40,         40,        1,   191816, 39fd9856c94d386633ac796fbe159904
 -0,         41,         41,        1,   191552, 2f5b8e24915c66a5213e8a587368c538
 -0,         42,         42,        1,   191556, 28a1056a5f58b2916d8151def7e102af
 -0,         43,         43,        1,   191704, 30000db8f792b0b762d4c9ea1b442d0b
 -0,         44,         44,        1,   191792, 013de9696edc2cdfcd81d239be89a988
 -0,         45,         45,        1,   191952, 44ed3f7914e4c2e7b51ecdcefbef36db
 -0,         46,         46,        1,   191924, 764583676fd2595cedf13d61c4d4339a
 -0,         47,         47,        1,   191788, bb29d4f35e3d05e7851c986ba410a551
 -0,         48,         48,        1,   191716, 2ade356badd31d5f2208c512c374671d
 -0,         49,         49,        1,   191736, 29c0753eb219082c9f7dca220a4c50ec
+ #tb 0: 1/25
++0,          0,          0,        1,   191788, ff02a91e03b0a94b37af9ea51ab68242
++0,          1,          1,        1,   191808, 655052bb397edc4391f1eb650dc47871
++0,          2,          2,        1,   191652, fa6238888b811ede6e9c9f62e70dd0f7
++0,          3,          3,        1,   191680, 54d54092523e7930aa4a8f9368512281
++0,          4,          4,        1,   191964, 5ef03667afca82f49916ae83e195882a
++0,          5,          5,        1,   191748, dac12c404963c2e0ae5b48a7fdf73e77
++0,          6,          6,        1,   191708, 040941871e8c877f187bcf6bf4ced7e9
++0,          7,          7,        1,   191676, 9743925e523417ebb8bc67398db998bb
++0,          8,          8,        1,   191564, 1ed1955e9917b449820910a7f0b32ccf
++0,          9,          9,        1,   191548, d5c4c8105156760a0ec6fe301ecdf21c
++0,         10,         10,        1,   191456, dbc73bc7e39f40fc270bf679f581d4dd
++0,         11,         11,        1,   191276, a824fb35c5ae1373cc7bf21b07cc8c76
++0,         12,         12,        1,   191688, bdb5ef586ef4ff64c4f4bde0ce0bfc51
++0,         13,         13,        1,   191412, 1639afbba6e6b5781355377e450cf8b4
++0,         14,         14,        1,   191408, 086b3cef987cc05cde1ab4e65a08eaa0
++0,         15,         15,        1,   191404, 72ba9aa193eb87d7ac7631abc1a57926
++0,         16,         16,        1,   191488, 20b5d383654a24966ae8cef0bb9797d9
++0,         17,         17,        1,   191568, 73a64fc6f24d33dc66c3f250bb2bb780
++0,         18,         18,        1,   191592, c53abd778e04e5c7872cc683f14d1573
++0,         19,         19,        1,   191604, 49a74ad438ecf106c5f463293b2b244c
++0,         20,         20,        1,   191588, 73424c3524c45610276116f947acf453
++0,         21,         21,        1,   191648, 931d156f5077fafc3d3de5992924bf04
++0,         22,         22,        1,   191536, 07e2afbbb3089ebe578606190c13d1d9
++0,         23,         23,        1,   191584, c4612e5016957be04efde7ed617ef366
++0,         24,         24,        1,   191636, dc050ed93382112e04c70671527a30f5
++0,         25,         25,        1,   191512, 185b3fce35bd0daec1863a867924e0af
++0,         26,         26,        1,   191632, 3943a51c9b74627cfb957ed48e2f05c9
++0,         27,         27,        1,   191796, 0b9f806f55ee7a4e3da57d020f55a506
++0,         28,         28,        1,   192012, 682a5ccd7ceabd0b78e082db56d0cdea
++0,         29,         29,        1,   191952, 125f8574ea41e351197a5ea19fdef534
++0,         30,         30,        1,   191724, 37a0f598b5499d8f87bc59e3533ae865
++0,         31,         31,        1,   191780, 4af30d848aae71f6b771772650f19855
++0,         32,         32,        1,   191624, 253d25de282366630257cc475bc25406
++0,         33,         33,        1,   191392, 00e0e8f4e9e957b11d8cd06c808564c3
++0,         34,         34,        1,   191328, a920f74d3c03b861156509dc1056bb15
++0,         35,         35,        1,   191532, bd46443a91845d421a1d602884c2752f
++0,         36,         36,        1,   191844, b1e04afa26a9bee13fc7cc2736987d8e
++0,         37,         37,        1,   191824, 611a706a43ad910e90bf8fd3818ca987
++0,         38,         38,        1,   191800, a810b661c6be0257df68252b36f7cf3d
++0,         39,         39,        1,   191692, 4560e8f9db047066e5140d59f408c82c
++0,         40,         40,        1,   191804, 1ba3a85b5a3f4ca503aa2ef4ae3a7b79
++0,         41,         41,        1,   191540, e739afb686e4d0d7ae2817ecc5fba584
++0,         42,         42,        1,   191536, fbb2e21954ff43b603c932ca03dd71d0
++0,         43,         43,        1,   191680, ee91c6758842419248ed5ecbdbdfaf89
++0,         44,         44,        1,   191784, 8137a4fd101c279d62ab23ef08bc763a
++0,         45,         45,        1,   191936, 838ee8574f632222c45866841749cd9c
++0,         46,         46,        1,   191912, 80f414eca8c544d09acac6696314a74b
++0,         47,         47,        1,   191772, 5e457f447e765b2f13e8e9a9af359ec8
++0,         48,         48,        1,   191704, 501ce8349316c6ab1c3100eecb31b551
++0,         49,         49,        1,   191720, 3999f5d44150a6e44cf4fe55a3d146e0