// Copyright 1999, Be Incorporated. All Rights Reserved.
// Copyright 2000-2004, Jun Suzuki. All Rights Reserved.
// Copyright 2007, Stephan Aßmus. All Rights Reserved.
// Copyright 2010, Haiku, Inc. All Rights Reserved.
// This file may be used under the terms of the Be Sample Code License.


#include "MediaFileInfo.h"

#include <Catalog.h>
#include <MediaTrack.h>
#include <StringFormat.h>
#include <stdio.h>

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "MediaFileInfo"

MediaFileInfo::MediaFileInfo(BMediaFile* file)
{
        LoadInfo(file);
}


status_t
MediaFileInfo::LoadInfo(BMediaFile* file)
{
        _Reset();
        if (!file)
                return B_BAD_VALUE;

        BMediaTrack* track;
        media_format format;
        format.Clear();
        media_codec_info codecInfo;
        bool audioDone(false), videoDone(false);
        bigtime_t audioDuration = 0;
        bigtime_t videoDuration = 0;
        int32 tracks = file->CountTracks();
        int64 videoFrames = 0;
        int64 audioFrames = 0;
        status_t ret = B_OK;

        for (int32 i = 0; i < tracks && (!audioDone || !videoDone); i++) {
                track = file->TrackAt(i);
                if (track == NULL)
                        return B_ERROR;

                ret = track->InitCheck();
                if (ret != B_OK)
                        return ret;

                ret = track->EncodedFormat(&format);
                if (ret != B_OK)
                        return ret;

                static BStringFormat frameFormat(B_TRANSLATE(
                        "{0, plural, one{# frame} other{# frames}}"));

                if (format.IsVideo()) {
                        format.Clear();
                        format.type = B_MEDIA_RAW_VIDEO;

                        ret = track->DecodedFormat(&format);
                        if (ret != B_OK)
                                return ret;

                        media_raw_video_format *rvf = &(format.u.raw_video);

                        ret = track->GetCodecInfo(&codecInfo);
                        if (ret != B_OK)
                                return ret;

                        video.format << codecInfo.pretty_name;
                        videoDuration = track->Duration();
                        videoFrames = track->CountFrames();

                        BString details;
                        details.SetToFormat(
                                B_TRANSLATE_COMMENT("%u × %u, %.2ffps", "Width × Height, fps;"
                                "The '×' is the Unicode multiplication sign U+00D7"),
                                (unsigned)format.Width(), (unsigned)format.Height(),
                                rvf->field_rate / rvf->interlace);

                        details << " / ";
                        frameFormat.Format(details, videoFrames);

                        video.details << details;
                        videoDone = true;

                } else if (format.IsAudio()) {
                        format.Clear();
                        format.type = B_MEDIA_RAW_AUDIO;
                        ret = track->DecodedFormat(&format);
                        if (ret != B_OK)
                                return ret;
                        media_raw_audio_format *raf = &(format.u.raw_audio);
                        char bytesPerSample = (char)(raf->format & 0xf);

                        BString details;
                        if (bytesPerSample == 1 || bytesPerSample == 2) {
                                static BStringFormat bitFormat(
                                        B_TRANSLATE("{0, plural, one{# bit} other{# bits}}"));
                                bitFormat.Format(details, bytesPerSample * 8);
                                details.SetToFormat(B_TRANSLATE("%d bit "), bytesPerSample * 8);
                        } else {
                                static BStringFormat bitFormat(
                                        B_TRANSLATE("{0, plural, one{# byte} other{# bytes}}"));
                                bitFormat.Format(details, bytesPerSample);
                        }
                        audio.details << details;
                        audio.details << " ";

                        ret = track->GetCodecInfo(&codecInfo);
                        if (ret != B_OK)
                                return ret;

                        audio.format << codecInfo.pretty_name;
                        audioDuration = track->Duration();
                        audioFrames = track->CountFrames();
                        BString channels;
                        if (raf->channel_count == 1) {
                                channels.SetToFormat(B_TRANSLATE("%.1f kHz mono"),
                                        raf->frame_rate / 1000.f);
                        } else if (raf->channel_count == 2) {
                                channels.SetToFormat(B_TRANSLATE("%.1f kHz stereo"),
                                        raf->frame_rate / 1000.f);
                        } else {
                                channels.SetToFormat(B_TRANSLATE("%.1f kHz %ld channel"),
                                        raf->frame_rate / 1000.f, (long int)raf->channel_count);
                        }

                        channels << " / ";
                        frameFormat.Format(channels, audioFrames);

                        audio.details << channels;

                        audioDone = true;
                }
                ret = file->ReleaseTrack(track);
                if (ret != B_OK)
                        return ret;
        }

        useconds = MAX(audioDuration, videoDuration);
        duration << (int32)(useconds / 1000000)
                        << B_TRANSLATE(" seconds");

        return B_OK;
}


void
MediaFileInfo::_Reset()
{
        audio.details.SetTo("");
        audio.format.SetTo("");
        video.details.SetTo("");
        video.format.SetTo("");
        useconds = 0;
        duration.SetTo("");
}