dump: Print AVAudioServiceType side data
[ffmpeg.git] / libavformat / dump.c
index ae285a3..3248e56 100644 (file)
 #include <stdio.h>
 #include <stdint.h>
 
+#include "libavutil/channel_layout.h"
+#include "libavutil/display.h"
+#include "libavutil/intreadwrite.h"
 #include "libavutil/log.h"
 #include "libavutil/mathematics.h"
+#include "libavutil/replaygain.h"
+#include "libavutil/stereo3d.h"
 
 #include "avformat.h"
 
@@ -111,11 +116,11 @@ static void print_fps(double d, const char *postfix)
 {
     uint64_t v = lrintf(d * 100);
     if (v % 100)
-        av_log(NULL, AV_LOG_INFO, "%3.2f %s", d, postfix);
+        av_log(NULL, AV_LOG_INFO, "%3.2f %s", d, postfix);
     else if (v % (100 * 1000))
-        av_log(NULL, AV_LOG_INFO, "%1.0f %s", d, postfix);
+        av_log(NULL, AV_LOG_INFO, "%1.0f %s", d, postfix);
     else
-        av_log(NULL, AV_LOG_INFO, "%1.0fk %s", d / 1000, postfix);
+        av_log(NULL, AV_LOG_INFO, "%1.0fk %s", d / 1000, postfix);
 }
 
 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
@@ -131,6 +136,239 @@ static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
     }
 }
 
+/* param change side data*/
+static void dump_paramchange(void *ctx, AVPacketSideData *sd)
+{
+    int size = sd->size;
+    const uint8_t *data = sd->data;
+    uint32_t flags, channels, sample_rate, width, height;
+    uint64_t layout;
+
+    if (!data || sd->size < 4)
+        goto fail;
+
+    flags = AV_RL32(data);
+    data += 4;
+    size -= 4;
+
+    if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
+        if (size < 4)
+            goto fail;
+        channels = AV_RL32(data);
+        data += 4;
+        size -= 4;
+        av_log(ctx, AV_LOG_INFO, "channel count %"PRIu32", ", channels);
+    }
+    if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
+        if (size < 8)
+            goto fail;
+        layout = AV_RL64(data);
+        data += 8;
+        size -= 8;
+        av_log(ctx, AV_LOG_INFO,
+               "channel layout: %s, ", av_get_channel_name(layout));
+    }
+    if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
+        if (size < 4)
+            goto fail;
+        sample_rate = AV_RL32(data);
+        data += 4;
+        size -= 4;
+        av_log(ctx, AV_LOG_INFO, "sample_rate %"PRIu32", ", sample_rate);
+    }
+    if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
+        if (size < 8)
+            goto fail;
+        width = AV_RL32(data);
+        data += 4;
+        size -= 4;
+        height = AV_RL32(data);
+        data += 4;
+        size -= 4;
+        av_log(ctx, AV_LOG_INFO, "width %"PRIu32" height %"PRIu32, width, height);
+    }
+
+    return;
+fail:
+    av_log(ctx, AV_LOG_INFO, "unknown param");
+}
+
+/* replaygain side data*/
+static void print_gain(void *ctx, const char *str, int32_t gain)
+{
+    av_log(ctx, AV_LOG_INFO, "%s - ", str);
+    if (gain == INT32_MIN)
+        av_log(ctx, AV_LOG_INFO, "unknown");
+    else
+        av_log(ctx, AV_LOG_INFO, "%f", gain / 100000.0f);
+    av_log(ctx, AV_LOG_INFO, ", ");
+}
+
+static void print_peak(void *ctx, const char *str, uint32_t peak)
+{
+    av_log(ctx, AV_LOG_INFO, "%s - ", str);
+    if (!peak)
+        av_log(ctx, AV_LOG_INFO, "unknown");
+    else
+        av_log(ctx, AV_LOG_INFO, "%f", (float) peak / UINT32_MAX);
+    av_log(ctx, AV_LOG_INFO, ", ");
+}
+
+static void dump_replaygain(void *ctx, AVPacketSideData *sd)
+{
+    AVReplayGain *rg;
+
+    if (sd->size < sizeof(*rg)) {
+        av_log(ctx, AV_LOG_INFO, "invalid data");
+        return;
+    }
+    rg = (AVReplayGain*)sd->data;
+
+    print_gain(ctx, "track gain", rg->track_gain);
+    print_peak(ctx, "track peak", rg->track_peak);
+    print_gain(ctx, "album gain", rg->album_gain);
+    print_peak(ctx, "album peak", rg->album_peak);
+}
+
+static void dump_stereo3d(void *ctx, AVPacketSideData *sd)
+{
+    AVStereo3D *stereo;
+
+    if (sd->size < sizeof(*stereo)) {
+        av_log(ctx, AV_LOG_INFO, "invalid data");
+        return;
+    }
+
+    stereo = (AVStereo3D *)sd->data;
+
+    switch (stereo->type) {
+    case AV_STEREO3D_2D:
+        av_log(ctx, AV_LOG_INFO, "2D");
+        break;
+    case AV_STEREO3D_SIDEBYSIDE:
+        av_log(ctx, AV_LOG_INFO, "side by side");
+        break;
+    case AV_STEREO3D_TOPBOTTOM:
+        av_log(ctx, AV_LOG_INFO, "top and bottom");
+        break;
+    case AV_STEREO3D_FRAMESEQUENCE:
+        av_log(ctx, AV_LOG_INFO, "frame alternate");
+        break;
+    case AV_STEREO3D_CHECKERBOARD:
+        av_log(ctx, AV_LOG_INFO, "checkerboard");
+        break;
+    case AV_STEREO3D_LINES:
+        av_log(ctx, AV_LOG_INFO, "interleaved lines");
+        break;
+    case AV_STEREO3D_COLUMNS:
+        av_log(ctx, AV_LOG_INFO, "interleaved columns");
+        break;
+    case AV_STEREO3D_SIDEBYSIDE_QUINCUNX:
+        av_log(ctx, AV_LOG_INFO, "side by side (quincunx subsampling)");
+        break;
+    default:
+        av_log(ctx, AV_LOG_WARNING, "unknown");
+        break;
+    }
+
+    if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
+        av_log(ctx, AV_LOG_INFO, " (inverted)");
+}
+
+static void dump_audioservicetype(void *ctx, AVPacketSideData *sd)
+{
+    enum AVAudioServiceType *ast = (enum AVAudioServiceType *)sd->data;
+
+    if (sd->size < sizeof(*ast)) {
+        av_log(ctx, AV_LOG_INFO, "invalid data");
+        return;
+    }
+
+    switch (*ast) {
+    case AV_AUDIO_SERVICE_TYPE_MAIN:
+        av_log(ctx, AV_LOG_INFO, "main");
+        break;
+    case AV_AUDIO_SERVICE_TYPE_EFFECTS:
+        av_log(ctx, AV_LOG_INFO, "effects");
+        break;
+    case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
+        av_log(ctx, AV_LOG_INFO, "visually impaired");
+        break;
+    case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
+        av_log(ctx, AV_LOG_INFO, "hearing impaired");
+        break;
+    case AV_AUDIO_SERVICE_TYPE_DIALOGUE:
+        av_log(ctx, AV_LOG_INFO, "dialogue");
+        break;
+    case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
+        av_log(ctx, AV_LOG_INFO, "comentary");
+        break;
+    case AV_AUDIO_SERVICE_TYPE_EMERGENCY:
+        av_log(ctx, AV_LOG_INFO, "emergency");
+        break;
+    case AV_AUDIO_SERVICE_TYPE_VOICE_OVER:
+        av_log(ctx, AV_LOG_INFO, "voice over");
+        break;
+    case AV_AUDIO_SERVICE_TYPE_KARAOKE:
+        av_log(ctx, AV_LOG_INFO, "karaoke");
+        break;
+    default:
+        av_log(ctx, AV_LOG_WARNING, "unknown");
+        break;
+    }
+}
+
+static void dump_sidedata(void *ctx, AVStream *st, const char *indent)
+{
+    int i;
+
+    if (st->nb_side_data)
+        av_log(ctx, AV_LOG_INFO, "%sSide data:\n", indent);
+
+    for (i = 0; i < st->nb_side_data; i++) {
+        AVPacketSideData sd = st->side_data[i];
+        av_log(ctx, AV_LOG_INFO, "%s  ", indent);
+
+        switch (sd.type) {
+        case AV_PKT_DATA_PALETTE:
+            av_log(ctx, AV_LOG_INFO, "palette");
+            break;
+        case AV_PKT_DATA_NEW_EXTRADATA:
+            av_log(ctx, AV_LOG_INFO, "new extradata");
+            break;
+        case AV_PKT_DATA_PARAM_CHANGE:
+            av_log(ctx, AV_LOG_INFO, "paramchange: ");
+            dump_paramchange(ctx, &sd);
+            break;
+        case AV_PKT_DATA_H263_MB_INFO:
+            av_log(ctx, AV_LOG_INFO, "h263 macroblock info");
+            break;
+        case AV_PKT_DATA_REPLAYGAIN:
+            av_log(ctx, AV_LOG_INFO, "replaygain: ");
+            dump_replaygain(ctx, &sd);
+            break;
+        case AV_PKT_DATA_DISPLAYMATRIX:
+            av_log(ctx, AV_LOG_INFO, "displaymatrix: rotation of %.2f degrees",
+                   av_display_rotation_get((int32_t *)sd.data));
+            break;
+        case AV_PKT_DATA_STEREO3D:
+            av_log(ctx, AV_LOG_INFO, "stereo3d: ");
+            dump_stereo3d(ctx, &sd);
+            break;
+        case AV_PKT_DATA_AUDIO_SERVICE_TYPE:
+            av_log(ctx, AV_LOG_INFO, "audio service type: ");
+            dump_audioservicetype(ctx, &sd);
+            break;
+        default:
+            av_log(ctx, AV_LOG_WARNING,
+                   "unknown side data type %d (%d bytes)", sd.type, sd.size);
+            break;
+        }
+
+        av_log(ctx, AV_LOG_INFO, "\n");
+    }
+}
+
 /* "user interface" functions */
 static void dump_stream_format(AVFormatContext *ic, int i,
                                int index, int is_output)
@@ -138,11 +376,10 @@ static void dump_stream_format(AVFormatContext *ic, int i,
     char buf[256];
     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
     AVStream *st = ic->streams[i];
-    int g = av_gcd(st->time_base.num, st->time_base.den);
     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
 
     avcodec_string(buf, sizeof(buf), st->codec, is_output);
-    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
+    av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
 
     /* the pid is an important information, so we display it */
     /* XXX: add a generic system */
@@ -151,7 +388,7 @@ static void dump_stream_format(AVFormatContext *ic, int i,
     if (lang)
         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
-           st->time_base.num / g, st->time_base.den / g);
+           st->time_base.num, st->time_base.den);
     av_log(NULL, AV_LOG_INFO, ": %s", buf);
 
     if (st->sample_aspect_ratio.num && // default
@@ -167,11 +404,17 @@ static void dump_stream_format(AVFormatContext *ic, int i,
     }
 
     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
-        if (st->avg_frame_rate.den && st->avg_frame_rate.num)
-            print_fps(av_q2d(st->avg_frame_rate), "fps");
-        if (st->time_base.den && st->time_base.num)
-            print_fps(1 / av_q2d(st->time_base), "tbn");
-        if (st->codec->time_base.den && st->codec->time_base.num)
+        int fps = st->avg_frame_rate.den && st->avg_frame_rate.num;
+        int tbn = st->time_base.den && st->time_base.num;
+        int tbc = st->codec->time_base.den && st->codec->time_base.num;
+
+        if (fps || tbn || tbc)
+            av_log(NULL, AV_LOG_INFO, "\n      ");
+        if (fps)
+            print_fps(av_q2d(st->avg_frame_rate), tbn || tbc ? "fps, " : "fps");
+        if (tbn)
+            print_fps(1 / av_q2d(st->time_base), tbc ? "tbn, " : "tbn");
+        if (tbc)
             print_fps(1 / av_q2d(st->codec->time_base), "tbc");
     }
 
@@ -198,6 +441,8 @@ static void dump_stream_format(AVFormatContext *ic, int i,
     av_log(NULL, AV_LOG_INFO, "\n");
 
     dump_metadata(NULL, st->metadata, "    ");
+
+    dump_sidedata(NULL, st, "    ");
 }
 
 void av_dump_format(AVFormatContext *ic, int index,
@@ -248,7 +493,7 @@ void av_dump_format(AVFormatContext *ic, int index,
 
     for (i = 0; i < ic->nb_chapters; i++) {
         AVChapter *ch = ic->chapters[i];
-        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
+        av_log(NULL, AV_LOG_INFO, "    Chapter #%d:%d: ", index, i);
         av_log(NULL, AV_LOG_INFO,
                "start %f, ", ch->start * av_q2d(ch->time_base));
         av_log(NULL, AV_LOG_INFO,