avprobe: Zero the allocated avio buffer memory
[ffmpeg.git] / avprobe.c
index 3a0ee28..5b9a7ec 100644 (file)
--- a/avprobe.c
+++ b/avprobe.c
 
 #include "libavformat/avformat.h"
 #include "libavcodec/avcodec.h"
+#include "libavutil/avstring.h"
+#include "libavutil/display.h"
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
+#include "libavutil/stereo3d.h"
 #include "libavutil/dict.h"
+#include "libavutil/libm.h"
 #include "libavdevice/avdevice.h"
 #include "cmdutils.h"
 
+typedef struct InputStream {
+    AVStream *st;
+
+    AVCodecContext *dec_ctx;
+} InputStream;
+
+typedef struct InputFile {
+    AVFormatContext *fmt_ctx;
+
+    InputStream *streams;
+    int       nb_streams;
+} InputFile;
+
 const char program_name[] = "avprobe";
 const int program_birth_year = 2007;
 
@@ -44,9 +61,9 @@ static int use_byte_value_binary_prefix = 0;
 static int use_value_sexagesimal_format = 0;
 
 /* globals */
-static const OptionDef options[];
+static const OptionDef *options;
 
-/* AVprobe context */
+/* avprobe context */
 static const char *input_filename;
 static AVInputFormat *iformat = NULL;
 
@@ -58,10 +75,9 @@ static const char unit_hertz_str[]          = "Hz"   ;
 static const char unit_byte_str[]           = "byte" ;
 static const char unit_bit_per_second_str[] = "bit/s";
 
-void exit_program(int ret)
+static void avprobe_cleanup(int ret)
 {
     av_dict_free(&fmt_entries_to_show);
-    exit(ret);
 }
 
 /*
@@ -81,32 +97,32 @@ void exit_program(int ret)
 typedef enum {
     ARRAY,
     OBJECT
-} ProbeElementType;
+} PrintElementType;
 
-typedef struct {
+typedef struct PrintElement {
     const char *name;
-    ProbeElementType type;
+    PrintElementType type;
     int64_t index;
     int64_t nb_elems;
-} ProbeElement;
+} PrintElement;
 
-typedef struct {
-    ProbeElement *prefix;
+typedef struct PrintContext {
+    PrintElement *prefix;
     int level;
     void (*print_header)(void);
     void (*print_footer)(void);
 
-    void (*print_array_header) (const char *name);
-    void (*print_array_footer) (const char *name);
+    void (*print_array_header) (const char *name, int plain_values);
+    void (*print_array_footer) (const char *name, int plain_values);
     void (*print_object_header)(const char *name);
     void (*print_object_footer)(const char *name);
 
     void (*print_integer) (const char *key, int64_t value);
     void (*print_string)  (const char *key, const char *value);
-} OutputContext;
+} PrintContext;
 
 static AVIOContext *probe_out = NULL;
-static OutputContext octx;
+static PrintContext octx;
 #define AVP_INDENT() avio_printf(probe_out, "%*c", octx.level * 2, ' ')
 
 /*
@@ -156,16 +172,28 @@ static void ini_escape_print(const char *s)
     }
 }
 
-static void ini_print_array_header(const char *name)
+static void ini_print_array_header(const char *name, int plain_values)
 {
-    if (octx.prefix[octx.level -1].nb_elems)
+    if (!plain_values) {
+        /* Add a new line if we create a new full group */
+        if (octx.prefix[octx.level -1].nb_elems)
+            avio_printf(probe_out, "\n");
+    } else {
+        ini_escape_print(name);
+        avio_w8(probe_out, '=');
+    }
+}
+
+static void ini_print_array_footer(const char *name, int plain_values)
+{
+    if (plain_values)
         avio_printf(probe_out, "\n");
 }
 
 static void ini_print_object_header(const char *name)
 {
     int i;
-    ProbeElement *el = octx.prefix + octx.level -1;
+    PrintElement *el = octx.prefix + octx.level -1;
 
     if (el->nb_elems)
         avio_printf(probe_out, "\n");
@@ -180,15 +208,21 @@ static void ini_print_object_header(const char *name)
     }
 
     avio_printf(probe_out, "%s", name);
-    if (el && el->type == ARRAY)
+    if (el->type == ARRAY)
         avio_printf(probe_out, ".%"PRId64"", el->nb_elems);
     avio_printf(probe_out, "]\n");
 }
 
 static void ini_print_integer(const char *key, int64_t value)
 {
-    ini_escape_print(key);
-    avio_printf(probe_out, "=%"PRId64"\n", value);
+    if (key) {
+        ini_escape_print(key);
+        avio_printf(probe_out, "=%"PRId64"\n", value);
+    } else {
+        if (octx.prefix[octx.level -1].nb_elems)
+            avio_printf(probe_out, ",");
+        avio_printf(probe_out, "%"PRId64, value);
+    }
 }
 
 
@@ -213,7 +247,7 @@ static void json_print_footer(void)
     avio_printf(probe_out, "}\n");
 }
 
-static void json_print_array_header(const char *name)
+static void json_print_array_header(const char *name, int plain_values)
 {
     if (octx.prefix[octx.level -1].nb_elems)
         avio_printf(probe_out, ",\n");
@@ -222,7 +256,7 @@ static void json_print_array_header(const char *name)
     avio_printf(probe_out, "[\n");
 }
 
-static void json_print_array_footer(const char *name)
+static void json_print_array_footer(const char *name, int plain_values)
 {
     avio_printf(probe_out, "\n");
     AVP_INDENT();
@@ -248,10 +282,18 @@ static void json_print_object_footer(const char *name)
 
 static void json_print_integer(const char *key, int64_t value)
 {
-    if (octx.prefix[octx.level -1].nb_elems)
-        avio_printf(probe_out, ",\n");
-    AVP_INDENT();
-    avio_printf(probe_out, "\"%s\" : %"PRId64"", key, value);
+    if (key) {
+        if (octx.prefix[octx.level -1].nb_elems)
+            avio_printf(probe_out, ",\n");
+        AVP_INDENT();
+        avio_printf(probe_out, "\"%s\" : ", key);
+    } else {
+        if (octx.prefix[octx.level -1].nb_elems)
+            avio_printf(probe_out, ", ");
+        else
+            AVP_INDENT();
+    }
+    avio_printf(probe_out, "%"PRId64, value);
 }
 
 static void json_escape_print(const char *s)
@@ -301,8 +343,10 @@ static void old_print_object_header(const char *name)
         return;
 
     str = p = av_strdup(name);
+    if (!str)
+        return;
     while (*p) {
-        *p = toupper(*p);
+        *p = av_toupper(*p);
         p++;
     }
 
@@ -318,8 +362,10 @@ static void old_print_object_footer(const char *name)
         return;
 
     str = p = av_strdup(name);
+    if (!str)
+        return;
     while (*p) {
-        *p = toupper(*p);
+        *p = av_toupper(*p);
         p++;
     }
 
@@ -361,21 +407,21 @@ static void probe_group_enter(const char *name, int type)
     int64_t count = -1;
 
     octx.prefix =
-        av_realloc(octx.prefix, sizeof(ProbeElement) * (octx.level + 1));
+        av_realloc(octx.prefix, sizeof(PrintElement) * (octx.level + 1));
 
     if (!octx.prefix || !name) {
         fprintf(stderr, "Out of memory\n");
-        exit(1);
+        exit_program(1);
     }
 
     if (octx.level) {
-        ProbeElement *parent = octx.prefix + octx.level -1;
+        PrintElement *parent = octx.prefix + octx.level -1;
         if (parent->type == ARRAY)
             count = parent->nb_elems;
         parent->nb_elems++;
     }
 
-    octx.prefix[octx.level++] = (ProbeElement){name, type, count, 0};
+    octx.prefix[octx.level++] = (PrintElement){name, type, count, 0};
 }
 
 static void probe_group_leave(void)
@@ -398,19 +444,19 @@ static void probe_footer(void)
 }
 
 
-static void probe_array_header(const char *name)
+static void probe_array_header(const char *name, int plain_values)
 {
     if (octx.print_array_header)
-        octx.print_array_header(name);
+        octx.print_array_header(name, plain_values);
 
     probe_group_enter(name, ARRAY);
 }
 
-static void probe_array_footer(const char *name)
+static void probe_array_footer(const char *name, int plain_values)
 {
     probe_group_leave();
     if (octx.print_array_footer)
-        octx.print_array_footer(name);
+        octx.print_array_footer(name, plain_values);
 }
 
 static void probe_object_header(const char *name)
@@ -468,7 +514,7 @@ static char *value_string(char *buf, int buf_size, double val, const char *unit)
         int index;
 
         if (unit == unit_byte_str && use_byte_value_binary_prefix) {
-            index = (int) (log(val)/log(2)) / 10;
+            index = (int) log2(val) / 10;
             index = av_clip(index, 0, FF_ARRAY_ELEMS(binary_unit_prefixes) - 1);
             val  /= pow(2, index * 10);
             prefix_string = binary_unit_prefixes[index];
@@ -525,27 +571,13 @@ static char *tag_string(char *buf, int buf_size, int tag)
     return buf;
 }
 
-
-
-static const char *media_type_string(enum AVMediaType media_type)
-{
-    switch (media_type) {
-    case AVMEDIA_TYPE_VIDEO:      return "video";
-    case AVMEDIA_TYPE_AUDIO:      return "audio";
-    case AVMEDIA_TYPE_DATA:       return "data";
-    case AVMEDIA_TYPE_SUBTITLE:   return "subtitle";
-    case AVMEDIA_TYPE_ATTACHMENT: return "attachment";
-    default:                      return "unknown";
-    }
-}
-
 static void show_packet(AVFormatContext *fmt_ctx, AVPacket *pkt)
 {
     char val_str[128];
     AVStream *st = fmt_ctx->streams[pkt->stream_index];
 
     probe_object_header("packet");
-    probe_str("codec_type", media_type_string(st->codec->codec_type));
+    probe_str("codec_type", media_type_string(st->codecpar->codec_type));
     probe_int("stream_index", pkt->stream_index);
     probe_str("pts", ts_value_string(val_str, sizeof(val_str), pkt->pts));
     probe_str("pts_time", time_value_string(val_str, sizeof(val_str),
@@ -565,98 +597,117 @@ static void show_packet(AVFormatContext *fmt_ctx, AVPacket *pkt)
     probe_object_footer("packet");
 }
 
-static void show_packets(AVFormatContext *fmt_ctx)
+static void show_packets(InputFile *ifile)
 {
+    AVFormatContext *fmt_ctx = ifile->fmt_ctx;
     AVPacket pkt;
 
     av_init_packet(&pkt);
-    probe_array_header("packets");
-    while (!av_read_frame(fmt_ctx, &pkt))
+    probe_array_header("packets", 0);
+    while (!av_read_frame(fmt_ctx, &pkt)) {
         show_packet(fmt_ctx, &pkt);
-    probe_array_footer("packets");
+        av_packet_unref(&pkt);
+    }
+    probe_array_footer("packets", 0);
 }
 
-static void show_stream(AVFormatContext *fmt_ctx, int stream_idx)
+static void show_stream(InputFile *ifile, InputStream *ist)
 {
-    AVStream *stream = fmt_ctx->streams[stream_idx];
+    AVFormatContext *fmt_ctx = ifile->fmt_ctx;
+    AVStream *stream = ist->st;
+    AVCodecParameters *par;
     AVCodecContext *dec_ctx;
-    AVCodec *dec;
+    const AVCodecDescriptor *codec_desc;
     const char *profile;
     char val_str[128];
-    AVRational display_aspect_ratio;
+    AVRational display_aspect_ratio, *sar = NULL;
+    const AVPixFmtDescriptor *desc;
 
     probe_object_header("stream");
 
     probe_int("index", stream->index);
 
-    if ((dec_ctx = stream->codec)) {
-        if ((dec = dec_ctx->codec)) {
-            probe_str("codec_name", dec->name);
-            probe_str("codec_long_name", dec->long_name);
-        } else {
-            probe_str("codec_name", "unknown");
-        }
+    par     = stream->codecpar;
+    dec_ctx = ist->dec_ctx;
+    codec_desc = avcodec_descriptor_get(par->codec_id);
+    if (codec_desc) {
+        probe_str("codec_name", codec_desc->name);
+        probe_str("codec_long_name", codec_desc->long_name);
+    } else {
+        probe_str("codec_name", "unknown");
+    }
 
-        probe_str("codec_type", media_type_string(dec_ctx->codec_type));
-        probe_str("codec_time_base",
-                  rational_string(val_str, sizeof(val_str),
-                                  "/", &dec_ctx->time_base));
-
-        /* print AVI/FourCC tag */
-        av_get_codec_tag_string(val_str, sizeof(val_str), dec_ctx->codec_tag);
-        probe_str("codec_tag_string", val_str);
-        probe_str("codec_tag", tag_string(val_str, sizeof(val_str),
-                                          dec_ctx->codec_tag));
-
-        /* print profile, if there is one */
-        if (dec && (profile = av_get_profile_name(dec, dec_ctx->profile)))
-            probe_str("profile", profile);
-
-        switch (dec_ctx->codec_type) {
-        case AVMEDIA_TYPE_VIDEO:
-            probe_int("width", dec_ctx->width);
-            probe_int("height", dec_ctx->height);
+    probe_str("codec_type", media_type_string(par->codec_type));
+
+    /* print AVI/FourCC tag */
+    av_get_codec_tag_string(val_str, sizeof(val_str), par->codec_tag);
+    probe_str("codec_tag_string", val_str);
+    probe_str("codec_tag", tag_string(val_str, sizeof(val_str),
+                                      par->codec_tag));
+
+    /* print profile, if there is one */
+    profile = avcodec_profile_name(par->codec_id, par->profile);
+    if (profile)
+        probe_str("profile", profile);
+
+    switch (par->codec_type) {
+    case AVMEDIA_TYPE_VIDEO:
+        probe_int("width",  par->width);
+        probe_int("height", par->height);
+        if (dec_ctx) {
+            probe_int("coded_width",  dec_ctx->coded_width);
+            probe_int("coded_height", dec_ctx->coded_height);
             probe_int("has_b_frames", dec_ctx->has_b_frames);
-            if (dec_ctx->sample_aspect_ratio.num) {
-                probe_str("sample_aspect_ratio",
-                          rational_string(val_str, sizeof(val_str), ":",
-                          &dec_ctx->sample_aspect_ratio));
-                av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
-                          dec_ctx->width  * dec_ctx->sample_aspect_ratio.num,
-                          dec_ctx->height * dec_ctx->sample_aspect_ratio.den,
-                          1024*1024);
-                probe_str("display_aspect_ratio",
-                          rational_string(val_str, sizeof(val_str), ":",
-                          &display_aspect_ratio));
-            }
-            probe_str("pix_fmt",
-                      dec_ctx->pix_fmt != PIX_FMT_NONE ? av_pix_fmt_descriptors[dec_ctx->pix_fmt].name
-                                                    : "unknown");
-            probe_int("level", dec_ctx->level);
-            break;
-
-        case AVMEDIA_TYPE_AUDIO:
-            probe_str("sample_rate",
-                      value_string(val_str, sizeof(val_str),
-                                   dec_ctx->sample_rate,
-                                   unit_hertz_str));
-            probe_int("channels", dec_ctx->channels);
-            probe_int("bits_per_sample",
-                      av_get_bits_per_sample(dec_ctx->codec_id));
-            break;
         }
-    } else {
-        probe_str("codec_type", "unknown");
+        if (dec_ctx && dec_ctx->sample_aspect_ratio.num)
+            sar = &dec_ctx->sample_aspect_ratio;
+        else if (par->sample_aspect_ratio.num)
+            sar = &par->sample_aspect_ratio;
+        else if (stream->sample_aspect_ratio.num)
+            sar = &stream->sample_aspect_ratio;
+
+        if (sar) {
+            probe_str("sample_aspect_ratio",
+                      rational_string(val_str, sizeof(val_str), ":", sar));
+            av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
+                      par->width  * sar->num, par->height * sar->den,
+                      1024*1024);
+            probe_str("display_aspect_ratio",
+                      rational_string(val_str, sizeof(val_str), ":",
+                      &display_aspect_ratio));
+        }
+        desc = av_pix_fmt_desc_get(par->format);
+        probe_str("pix_fmt", desc ? desc->name : "unknown");
+        probe_int("level", par->level);
+
+        probe_str("color_range", av_color_range_name    (par->color_range));
+        probe_str("color_space", av_color_space_name    (par->color_space));
+        probe_str("color_trc",   av_color_transfer_name (par->color_trc));
+        probe_str("color_pri",   av_color_primaries_name(par->color_primaries));
+        probe_str("chroma_loc", av_chroma_location_name (par->chroma_location));
+        break;
+
+    case AVMEDIA_TYPE_AUDIO:
+        probe_str("sample_rate",
+                  value_string(val_str, sizeof(val_str),
+                               par->sample_rate,
+                               unit_hertz_str));
+        probe_int("channels", par->channels);
+        probe_int("bits_per_sample",
+                  av_get_bits_per_sample(par->codec_id));
+        break;
     }
 
     if (fmt_ctx->iformat->flags & AVFMT_SHOW_IDS)
         probe_int("id", stream->id);
-    probe_str("r_frame_rate",
-              rational_string(val_str, sizeof(val_str), "/",
-              &stream->r_frame_rate));
     probe_str("avg_frame_rate",
               rational_string(val_str, sizeof(val_str), "/",
               &stream->avg_frame_rate));
+
+    if (par->bit_rate)
+        probe_str("bit_rate",
+                  value_string(val_str, sizeof(val_str),
+                               par->bit_rate, unit_bit_per_second_str));
     probe_str("time_base",
               rational_string(val_str, sizeof(val_str), "/",
               &stream->time_base));
@@ -671,11 +722,44 @@ static void show_stream(AVFormatContext *fmt_ctx, int stream_idx)
 
     probe_dict(stream->metadata, "tags");
 
+    if (stream->nb_side_data) {
+        int i, j;
+
+        probe_object_header("sidedata");
+        for (i = 0; i < stream->nb_side_data; i++) {
+            const AVPacketSideData* sd = &stream->side_data[i];
+            AVStereo3D *stereo;
+
+            switch (sd->type) {
+            case AV_PKT_DATA_DISPLAYMATRIX:
+                probe_object_header("displaymatrix");
+                probe_array_header("matrix", 1);
+                for (j = 0; j < 9; j++)
+                    probe_int(NULL, ((int32_t *)sd->data)[j]);
+                probe_array_footer("matrix", 1);
+                probe_int("rotation",
+                          av_display_rotation_get((int32_t *)sd->data));
+                probe_object_footer("displaymatrix");
+                break;
+            case AV_PKT_DATA_STEREO3D:
+                stereo = (AVStereo3D *)sd->data;
+                probe_object_header("stereo3d");
+                probe_str("type", av_stereo3d_type_name(stereo->type));
+                probe_int("inverted",
+                          !!(stereo->flags & AV_STEREO3D_FLAG_INVERT));
+                probe_object_footer("stereo3d");
+                break;
+            }
+        }
+        probe_object_footer("sidedata");
+    }
+
     probe_object_footer("stream");
 }
 
-static void show_format(AVFormatContext *fmt_ctx)
+static void show_format(InputFile *ifile)
 {
+    AVFormatContext *fmt_ctx = ifile->fmt_ctx;
     char val_str[128];
     int64_t size = fmt_ctx->pb ? avio_size(fmt_ctx->pb) : -1;
 
@@ -703,7 +787,7 @@ static void show_format(AVFormatContext *fmt_ctx)
     probe_object_footer("format");
 }
 
-static int open_input_file(AVFormatContext **fmt_ctx_ptr, const char *filename)
+static int open_input_file(InputFile *ifile, const char *filename)
 {
     int err, i;
     AVFormatContext *fmt_ctx = NULL;
@@ -728,61 +812,95 @@ static int open_input_file(AVFormatContext **fmt_ctx_ptr, const char *filename)
 
     av_dump_format(fmt_ctx, 0, filename, 0);
 
+    ifile->streams = av_mallocz_array(fmt_ctx->nb_streams,
+                                      sizeof(*ifile->streams));
+    if (!ifile->streams)
+        exit(1);
+    ifile->nb_streams = fmt_ctx->nb_streams;
+
     /* bind a decoder to each input stream */
     for (i = 0; i < fmt_ctx->nb_streams; i++) {
+        InputStream *ist = &ifile->streams[i];
         AVStream *stream = fmt_ctx->streams[i];
         AVCodec *codec;
 
-        if (!(codec = avcodec_find_decoder(stream->codec->codec_id))) {
+        ist->st = stream;
+
+        if (stream->codecpar->codec_id == AV_CODEC_ID_PROBE) {
+            fprintf(stderr, "Failed to probe codec for input stream %d\n",
+                    stream->index);
+            continue;
+        }
+
+        codec = avcodec_find_decoder(stream->codecpar->codec_id);
+        if (!codec) {
             fprintf(stderr,
                     "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) {
+                    stream->codecpar->codec_id, stream->index);
+            continue;
+        }
+
+        ist->dec_ctx = avcodec_alloc_context3(codec);
+        if (!ist->dec_ctx)
+            exit(1);
+
+        err = avcodec_parameters_to_context(ist->dec_ctx, stream->codecpar);
+        if (err < 0)
+            exit(1);
+
+        err = avcodec_open2(ist->dec_ctx, NULL, NULL);
+        if (err < 0) {
             fprintf(stderr, "Error while opening codec for input stream %d\n",
                     stream->index);
+            exit(1);
+
         }
     }
 
-    *fmt_ctx_ptr = fmt_ctx;
+    ifile->fmt_ctx = fmt_ctx;
     return 0;
 }
 
-static void close_input_file(AVFormatContext **ctx_ptr)
+static void close_input_file(InputFile *ifile)
 {
     int i;
-    AVFormatContext *fmt_ctx = *ctx_ptr;
 
     /* close decoder for each stream */
-    for (i = 0; i < fmt_ctx->nb_streams; i++) {
-        AVStream *stream = fmt_ctx->streams[i];
+    for (i = 0; i < ifile->nb_streams; i++) {
+        InputStream *ist = &ifile->streams[i];
 
-        avcodec_close(stream->codec);
+        avcodec_free_context(&ist->dec_ctx);
     }
-    avformat_close_input(ctx_ptr);
+
+    av_freep(&ifile->streams);
+    ifile->nb_streams = 0;
+
+    avformat_close_input(&ifile->fmt_ctx);
 }
 
 static int probe_file(const char *filename)
 {
-    AVFormatContext *fmt_ctx;
+    InputFile ifile;
     int ret, i;
 
-    if ((ret = open_input_file(&fmt_ctx, filename)))
+    ret = open_input_file(&ifile, filename);
+    if (ret < 0)
         return ret;
 
     if (do_show_format)
-        show_format(fmt_ctx);
+        show_format(&ifile);
 
     if (do_show_streams) {
-        probe_array_header("streams");
-        for (i = 0; i < fmt_ctx->nb_streams; i++)
-            show_stream(fmt_ctx, i);
-        probe_array_footer("streams");
+        probe_array_header("streams", 0);
+        for (i = 0; i < ifile.nb_streams; i++)
+            show_stream(&ifile, &ifile.streams[i]);
+        probe_array_footer("streams", 0);
     }
 
     if (do_show_packets)
-        show_packets(fmt_ctx);
+        show_packets(&ifile);
 
-    close_input_file(&fmt_ctx);
+    close_input_file(&ifile);
     return 0;
 }
 
@@ -793,7 +911,7 @@ static void show_usage(void)
     printf("\n");
 }
 
-static int opt_format(const char *opt, const char *arg)
+static int opt_format(void *optctx, const char *opt, const char *arg)
 {
     iformat = av_find_input_format(arg);
     if (!iformat) {
@@ -803,7 +921,7 @@ static int opt_format(const char *opt, const char *arg)
     return 0;
 }
 
-static int opt_output_format(const char *opt, const char *arg)
+static int opt_output_format(void *optctx, const char *opt, const char *arg)
 {
 
     if (!strcmp(arg, "json")) {
@@ -820,6 +938,7 @@ static int opt_output_format(const char *opt, const char *arg)
         octx.print_header        = ini_print_header;
         octx.print_footer        = ini_print_footer;
         octx.print_array_header  = ini_print_array_header;
+        octx.print_array_footer  = ini_print_array_footer;
         octx.print_object_header = ini_print_object_header;
 
         octx.print_integer = ini_print_integer;
@@ -837,7 +956,7 @@ static int opt_output_format(const char *opt, const char *arg)
     return 0;
 }
 
-static int opt_show_format_entry(const char *opt, const char *arg)
+static int opt_show_format_entry(void *optctx, const char *opt, const char *arg)
 {
     do_show_format = 1;
     nb_fmt_entries_to_show++;
@@ -860,50 +979,51 @@ static void opt_input_file(void *optctx, const char *arg)
         fprintf(stderr,
                 "Argument '%s' provided as input filename, but '%s' was already specified.\n",
                 arg, input_filename);
-        exit(1);
+        exit_program(1);
     }
     if (!strcmp(arg, "-"))
         arg = "pipe:";
     input_filename = arg;
 }
 
-static void show_help(void)
+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:\n", 0, 0);
+    show_help_options(options, "Main options:", 0, 0, 0);
     printf("\n");
     show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
 }
 
-static void opt_pretty(void)
+static int opt_pretty(void *optctx, 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 const OptionDef options[] = {
+static const OptionDef real_options[] = {
 #include "cmdutils_common_opts.h"
-    { "f", HAS_ARG, {(void*)opt_format}, "force format", "format" },
-    { "of", HAS_ARG, {(void*)&opt_output_format}, "output the document either as ini or json", "output_format" },
-    { "unit", OPT_BOOL, {(void*)&show_value_unit},
+    { "f", HAS_ARG, {.func_arg = opt_format}, "force format", "format" },
+    { "of", HAS_ARG, {.func_arg = opt_output_format}, "output the document either as ini or json", "output_format" },
+    { "unit", OPT_BOOL, {&show_value_unit},
       "show unit of the displayed values" },
-    { "prefix", OPT_BOOL, {(void*)&use_value_prefix},
+    { "prefix", OPT_BOOL, {&use_value_prefix},
       "use SI prefixes for the displayed values" },
-    { "byte_binary_prefix", OPT_BOOL, {(void*)&use_byte_value_binary_prefix},
+    { "byte_binary_prefix", OPT_BOOL, {&use_byte_value_binary_prefix},
       "use binary prefixes for byte units" },
-    { "sexagesimal", OPT_BOOL,  {(void*)&use_value_sexagesimal_format},
+    { "sexagesimal", OPT_BOOL,  {&use_value_sexagesimal_format},
       "use sexagesimal format HOURS:MM:SS.MICROSECONDS for time units" },
-    { "pretty", 0, {(void*)&opt_pretty},
+    { "pretty", 0, {.func_arg = opt_pretty},
       "prettify the format of displayed values, make it more human readable" },
-    { "show_format",  OPT_BOOL, {(void*)&do_show_format} , "show format/container info" },
-    { "show_format_entry", HAS_ARG, {(void*)opt_show_format_entry},
+    { "show_format",  OPT_BOOL, {&do_show_format} , "show format/container info" },
+    { "show_format_entry", HAS_ARG, {.func_arg = 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" },
-    { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default},
+    { "show_packets", OPT_BOOL, {&do_show_packets}, "show packets info" },
+    { "show_streams", OPT_BOOL, {&do_show_streams}, "show streams info" },
+    { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {.func_arg = opt_default},
       "generic catch all option", "" },
     { NULL, },
 };
@@ -919,11 +1039,14 @@ static int probe_buf_write(void *opaque, uint8_t *buf, int buf_size)
 int main(int argc, char **argv)
 {
     int ret;
-    uint8_t *buffer = av_malloc(AVP_BUFFSIZE);
+    uint8_t *buffer = av_mallocz(AVP_BUFFSIZE);
 
     if (!buffer)
         exit(1);
 
+    register_exit(avprobe_cleanup);
+
+    options = real_options;
     parse_loglevel(argc, argv, options);
     av_register_all();
     avformat_network_init();
@@ -933,6 +1056,17 @@ int main(int argc, char **argv)
 #endif
 
     show_banner();
+
+    octx.print_header = ini_print_header;
+    octx.print_footer = ini_print_footer;
+
+    octx.print_array_header = ini_print_array_header;
+    octx.print_array_footer = ini_print_array_footer;
+    octx.print_object_header = ini_print_object_header;
+
+    octx.print_integer = ini_print_integer;
+    octx.print_string = ini_print_string;
+
     parse_options(NULL, argc, argv, options, opt_input_file);
 
     if (!input_filename) {
@@ -941,28 +1075,20 @@ int main(int argc, char **argv)
         fprintf(stderr,
                 "Use -h to get full help or, even better, run 'man %s'.\n",
                 program_name);
-        exit(1);
+        exit_program(1);
     }
 
     probe_out = avio_alloc_context(buffer, AVP_BUFFSIZE, 1, NULL, NULL,
                                  probe_buf_write, NULL);
     if (!probe_out)
-        exit(1);
-
-    octx.print_header = ini_print_header;
-    octx.print_footer = ini_print_footer;
-
-    octx.print_array_header = ini_print_array_header;
-    octx.print_object_header = ini_print_object_header;
-
-    octx.print_integer = ini_print_integer;
-    octx.print_string = ini_print_string;
+        exit_program(1);
 
     probe_header();
     ret = probe_file(input_filename);
     probe_footer();
     avio_flush(probe_out);
-    avio_close(probe_out);
+    av_freep(&probe_out);
+    av_freep(&buffer);
 
     avformat_network_deinit();