/***********************************************************************
 * AUTHOR: David McPaul
 *   FILE: TimeCode.cpp
 *  DESCR: Handles all TimeCode functions.
 ***********************************************************************/
#include <TimeCode.h>
#include "MediaDebug.h"
#include <string.h>

status_t us_to_timecode(bigtime_t micros, int * hours, int * minutes, int * seconds, int * frames, const timecode_info * code)
{
        int32 l_frames;

        CALLED();

        if (code) {
                // We have a valid timecode_info
                switch (code->type) {
                        case    B_TIMECODE_DEFAULT:             // NTSC
                        case    B_TIMECODE_30_DROP_2:   // NTSC
                                l_frames = int32((((micros % 1000000) * 29.97) / 1000000) + (micros / 1000000 * 29.97));
                                break;
                        case    B_TIMECODE_30_DROP_4:   // Brazil
                                l_frames = int32((((micros % 1000000) * 29.95) / 1000000) + (micros / 1000000 * 29.95));
                                break;
                        default:
                                l_frames = (((micros % 1000000) * code->fps_div) / 1000000) + (micros / 1000000 * code->fps_div);
                                break;
                };
        } else {
                // Convert us to frames
                l_frames = int32((((micros % 1000000) * 29.97) / 1000000) + (micros / 1000000 * 29.97));
        }

        return frames_to_timecode(l_frames, hours, minutes, seconds, frames, code);
}

status_t timecode_to_us(int hours, int minutes, int seconds, int frames, bigtime_t * micros, const timecode_info * code)
{
        int32 l_frames;

        CALLED();

        if (timecode_to_frames(hours, minutes, seconds, frames, &l_frames, code) == B_OK) {

                if (code) {
                        // We have a valid timecode_info
                        switch (code->type) {
                                case    B_TIMECODE_DEFAULT:             // NTSC
                                case    B_TIMECODE_30_DROP_2:   // NTSC
                                        *micros = bigtime_t(l_frames * ((1000000 / 29.97) + 0.5));
                                        break;
                                case    B_TIMECODE_30_DROP_4:   // Brazil
                                        *micros = bigtime_t(l_frames * ((1000000 / 29.95) + 0.5));
                                        break;
                                default:
                                        *micros = l_frames * 1000000 / code->fps_div;
                                        break;
                        };

                } else {
                        *micros = bigtime_t(l_frames * ((1000000 / 29.97) + 0.5));
                }

                return B_OK;
        }
        return B_ERROR;
}

status_t frames_to_timecode(int32 l_frames, int * hours, int * minutes, int * seconds, int * frames, const timecode_info * code)
{
        int fps_div;
        int total_mins;
        int32 extra_frames;
        int32 extra_frames2;

        CALLED();

        if (code) {
                // We have a valid timecode_info so use it
                fps_div = code->fps_div;

                if (code->every_nth > 0) {
                        // Handle Drop Frames format

                        total_mins = l_frames / fps_div / 60;

                        // "every_nth" minute we gain "drop_frames" "except_nth" minute
                        extra_frames = code->drop_frames*(total_mins/code->every_nth) - code->drop_frames*(total_mins/code->except_nth);
                        l_frames += extra_frames;

                        total_mins = l_frames / fps_div / 60;
                        extra_frames2 = code->drop_frames*(total_mins/code->every_nth) - code->drop_frames*(total_mins/code->except_nth);

                        // Gaining frames may mean that we gain more frames so we keep adjusting until no more to adjust
                        while (extra_frames != extra_frames2) {
                                l_frames += extra_frames2 - extra_frames;
                                extra_frames = extra_frames2;

                                total_mins = l_frames / fps_div / 60;
                                extra_frames2 = code->drop_frames*(total_mins/code->every_nth) - code->drop_frames*(total_mins/code->except_nth);
                        }

                        // l_frames should now include all adjusted frames
                }
        } else {
                // no timecode_info so set default NTSC :-(
                fps_div = 30;           // NTSC Default
                total_mins = l_frames / fps_div / 60;

                // "every_nth" minute we gain "drop_frames" "except_nth" minute
                extra_frames = 2*(total_mins) - 2*(total_mins/10);
                l_frames += extra_frames;

                total_mins = l_frames / fps_div / 60;
                extra_frames2 = 2*(total_mins) - 2*(total_mins/10);

                // Gaining frames may mean that we gain more frames so we keep adjusting until no more to adjust
                while (extra_frames != extra_frames2) {
                        l_frames += extra_frames2 - extra_frames;
                        extra_frames = extra_frames2;

                        total_mins = l_frames / fps_div / 60;
                        extra_frames2 = 2*(total_mins) - 2*(total_mins/10);
                }
        }

        // convert frames to seconds leaving the remainder as frames
        *seconds = l_frames / fps_div;          // DIV
        *frames = l_frames % fps_div;           // MOD

        // Normalise to Hours Minutes Seconds Frames
        *minutes = *seconds / 60;
        *seconds = *seconds % 60;

        *hours = *minutes / 60;
        *minutes = *minutes % 60;

        return B_OK;
}

status_t timecode_to_frames(int hours, int minutes, int seconds, int frames, int32 * l_frames, const timecode_info * code)
{
        int fps_div;
        int total_mins;
        int32 extra_frames;

        CALLED();

        if (code) {
                // We have a valid timecode_info
                fps_div = code->fps_div;

                total_mins = (hours * 60) + minutes;
                *l_frames = (total_mins * 60) + seconds;
                *l_frames = (*l_frames * fps_div) + frames;

                // Adjust "every_nth" minute we lose "drop_frames" "except_nth" minute
                if (code->every_nth > 0) {
                        extra_frames = code->drop_frames*(total_mins/code->every_nth) - code->drop_frames*(total_mins/code->except_nth);

                        *l_frames = *l_frames - extra_frames;
                }
        } else {

                total_mins = (hours * 60) + minutes;
                *l_frames = (total_mins * 60) + seconds;
                *l_frames = (*l_frames * 30) + frames;

                // Adjust "every_nth" minute we lose "drop_frames" "except_nth" minute
                extra_frames = 2*(total_mins) - 2*(total_mins/10);

                *l_frames = *l_frames - extra_frames;
        }

        return B_OK;
}

status_t get_timecode_description(timecode_type type, timecode_info * out_timecode)
{
        CALLED();

        out_timecode->type = type;
        strncpy(out_timecode->format,"%.2ih:%.2im:%.2is.%.2i",31);
        out_timecode->every_nth = 0;
        out_timecode->except_nth = 0;

        switch (type) {
                case    B_TIMECODE_100:
                                strncpy(out_timecode->name,"100 FPS",31);
                                out_timecode->fps_div = 100;
                                break;
                case    B_TIMECODE_75:                  // CD
                                strncpy(out_timecode->name,"CD",31);
                                out_timecode->fps_div = 75;
                                break;
                case    B_TIMECODE_30:                  // MIDI
                                strncpy(out_timecode->name,"MIDI",31);
                                out_timecode->fps_div = 30;
                                break;
                case    B_TIMECODE_30_DROP_2:   // NTSC
                                strncpy(out_timecode->name,"NTSC",31);
                                out_timecode->fps_div = 30;     // This is supposed to be 29.97fps but can be simulated using the drop frame format below
                                out_timecode->drop_frames = 2; // Drop 2 frames
                                out_timecode->every_nth = 1;    // every 1 minutes
                                out_timecode->except_nth = 10;  // except every 10 minutes
                                break;
                case    B_TIMECODE_30_DROP_4:   // Brazil
                                strncpy(out_timecode->name,"NTSC Brazil",31);
                                out_timecode->fps_div = 30;
                                out_timecode->drop_frames = 4; // Drop 4 frames
                                out_timecode->every_nth = 1;    // every 1 minutes
                                out_timecode->except_nth = 10;  // except every 10 minutes
                                break;
                case    B_TIMECODE_25:                  // PAL
                                strncpy(out_timecode->name,"PAL",31);
                                out_timecode->fps_div = 25;
                                break;
                case    B_TIMECODE_24:                  // Film
                                strncpy(out_timecode->name,"FILM",31);
                                out_timecode->fps_div = 24;
                                break;
                case    B_TIMECODE_18:                  // Super8
                                strncpy(out_timecode->name,"Super 8",31);
                                out_timecode->fps_div = 18;
                                break;
                default:
                                strncpy(out_timecode->name,"NTSC",31);
                                out_timecode->fps_div = 30;     // This is supposed to be 29.97fps but can be simulated using the drop frame format below
                                out_timecode->drop_frames = 2; // Drop 2 frames
                                out_timecode->every_nth = 1;    // every 1 minutes
                                out_timecode->except_nth = 10;  // except every 10 minutes
                                break;
        }

        return B_OK;
}

status_t count_timecodes()
{
        CALLED();
        return 8;       // Is this right?
}

/*************************************************************
 * public BTimeCode
 *************************************************************/


BTimeCode::BTimeCode()
{
        CALLED();
}


BTimeCode::BTimeCode(bigtime_t us,
                                         timecode_type type)
{
        CALLED();
        if (SetType(type) == B_OK) {
                SetMicroseconds(us);
        }
}


BTimeCode::BTimeCode(const BTimeCode &clone)
{
        CALLED();
        if (SetType(clone.Type()) == B_OK) {
                SetData(clone.Hours(),clone.Minutes(),clone.Seconds(),clone.Frames());
        }
}


BTimeCode::BTimeCode(int hours,
                                         int minutes,
                                         int seconds,
                                         int frames,
                                         timecode_type type)
{
        CALLED();
        if (SetType(type) == B_OK) {
                SetData(hours,minutes,seconds,frames);
        }
}


BTimeCode::~BTimeCode()
{
        CALLED();
}


void
BTimeCode::SetData(int hours,
                                   int minutes,
                                   int seconds,
                                   int frames)
{
        CALLED();
        fHours = hours;
        fMinutes = minutes;
        fSeconds = seconds;
        fFrames = frames;
}


status_t
BTimeCode::SetType(timecode_type type)
{
        CALLED();

        return get_timecode_description(type, &fInfo);
}


void
BTimeCode::SetMicroseconds(bigtime_t us)
{
        CALLED();

        us_to_timecode(us, &fHours, &fMinutes, &fSeconds, &fFrames, &fInfo);
}


void
BTimeCode::SetLinearFrames(int32 linear_frames)
{
        CALLED();

        frames_to_timecode(linear_frames, &fHours, &fMinutes, &fSeconds, &fFrames, &fInfo);
}


BTimeCode &
BTimeCode::operator=(const BTimeCode &clone)
{
        CALLED();
        fHours = clone.Hours();
        fMinutes = clone.Minutes();
        fSeconds = clone.Seconds();
        fFrames = clone.Frames();
        SetType(clone.Type());

        return *this;
}


bool
BTimeCode::operator==(const BTimeCode &other) const
{
        CALLED();

        return ((this->LinearFrames()) == (other.LinearFrames()));
}


bool
BTimeCode::operator<(const BTimeCode &other) const
{
        CALLED();

        return ((this->LinearFrames()) < (other.LinearFrames()));
}


BTimeCode &
BTimeCode::operator+=(const BTimeCode &other)
{
        CALLED();

        this->SetLinearFrames(this->LinearFrames() + other.LinearFrames());

        return *this;
}


BTimeCode &
BTimeCode::operator-=(const BTimeCode &other)
{
        CALLED();

        this->SetLinearFrames(this->LinearFrames() - other.LinearFrames());

        return *this;
}


BTimeCode
BTimeCode::operator+(const BTimeCode &other) const
{
        CALLED();
        BTimeCode tc(*this);
        tc += other;
        return tc;
}


BTimeCode
BTimeCode::operator-(const BTimeCode &other) const
{
        CALLED();
        BTimeCode tc(*this);
        tc -= other;
        return tc;
}


int
BTimeCode::Hours() const
{
        CALLED();

        return fHours;
}


int
BTimeCode::Minutes() const
{
        CALLED();

        return fMinutes;
}


int
BTimeCode::Seconds() const
{
        CALLED();

        return fSeconds;
}


int
BTimeCode::Frames() const
{
        CALLED();

        return fFrames;
}


timecode_type
BTimeCode::Type() const
{
        CALLED();

        return fInfo.type;
}


void
BTimeCode::GetData(int *out_hours,
                                   int *out_minutes,
                                   int *out_seconds,
                                   int *out_frames,
                                   timecode_type *out_type) const
{
        CALLED();
        *out_hours = fHours;
        *out_minutes = fMinutes;
        *out_seconds = fSeconds;
        *out_frames = fFrames;
        *out_type = fInfo.type;
}


bigtime_t
BTimeCode::Microseconds() const
{
        bigtime_t us;

        CALLED();

        if (timecode_to_us(fHours,fMinutes,fSeconds,fFrames, &us, &fInfo) == B_OK) {
                return us;
        }

        return 0;
}


int32
BTimeCode::LinearFrames() const
{
        int32 linear_frames;

        CALLED();

        if (timecode_to_frames(fHours,fMinutes,fSeconds,fFrames,&linear_frames,&fInfo) == B_OK) {
                return linear_frames;
        }

        return 0;
}


void
BTimeCode::GetString(char *str) const
{
        CALLED();
        sprintf(str,fInfo.format, fHours, fMinutes, fSeconds, fFrames);
}