/*
 * Copyright (c) 2002, 2003 Marcus Overhagen <Marcus@Overhagen.de>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files or portions
 * thereof (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject
 * to the following conditions:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 *  * Redistributions in binary form must reproduce the above copyright notice
 *    in the  binary, as well as this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided with
 *    the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */

/*
 * The undocumented BTrackReader class,
 * used by BSound and the GameSound classes
 */

#include <File.h>
#include <MediaTrack.h>
#include <MediaFile.h>
#include <string.h>
#include "TrackReader.h"
#include "MediaDebug.h"

namespace BPrivate
{

BTrackReader::BTrackReader(BMediaTrack *track, media_raw_audio_format const &format) : 
        fFrameSize(0),
        fBuffer(0),
        fBufferOffset(0),
        fBufferUsedSize(0),
        fMediaFile(0),
        fMediaTrack(0),
        fFormat(format)
{
        CALLED();
        if (track == NULL)
                return;
        if (track->InitCheck() != B_OK)
                return;
                
        SetToTrack(track);

        // if the track was not set abort now
        if (fMediaTrack == 0)
                return;

        fBuffer = new uint8[fFormat.buffer_size];
        fFrameSize = fFormat.channel_count * (fFormat.format & media_raw_audio_format::B_AUDIO_SIZE_MASK);

        TRACE("BTrackReader::BTrackReader successful\n");
}


BTrackReader::BTrackReader(BFile *file, media_raw_audio_format const &format) : 
        fFrameSize(0),
        fBuffer(0),
        fBufferOffset(0),
        fBufferUsedSize(0),
        fMediaFile(0),
        fMediaTrack(0),
        fFormat(format)
{
        CALLED();
        if (file == NULL)
                return;
        if (file->InitCheck() != B_OK)
                return;
                
        fMediaFile = new BMediaFile(file);
        if (fMediaFile->InitCheck() != B_OK)
                return;
        
        int count = fMediaFile->CountTracks();
        if (count == 0) {
                ERROR("BTrackReader: no tracks in file\n");
                return;
        }

        // find the first audio track
        BMediaTrack *track;
        BMediaTrack *audiotrack = 0;
        for (int tr = 0; tr < count; tr++) {
                track = fMediaFile->TrackAt(tr);
                if (track == 0 || track->InitCheck() != B_OK)
                        continue;
                media_format fmt;
                if (track->DecodedFormat(&fmt) != B_OK)
                        continue;
                if (fmt.type == B_MEDIA_RAW_AUDIO) {
                        audiotrack = track;
                        break;
                }
                fMediaFile->ReleaseTrack(track);
        }
        if (audiotrack == 0) {
                ERROR("BTrackReader: no audio track in file\n");
                return;
        }
        
        SetToTrack(audiotrack);

        // if the track was not set, release it
        if (fMediaTrack == 0) {
                fMediaFile->ReleaseTrack(audiotrack);
                return;
        }

        fBuffer = new uint8[fFormat.buffer_size];
        fFrameSize = fFormat.channel_count * (fFormat.format & media_raw_audio_format::B_AUDIO_SIZE_MASK);

        TRACE("BTrackReader::BTrackReader successful\n");
}


void
BTrackReader::SetToTrack(BMediaTrack *track)
{       
        media_format fmt;
        fmt.Clear(); //wildcard
        memcpy(&fmt.u.raw_audio, &fFormat, sizeof(fFormat));
        fmt.type = B_MEDIA_RAW_AUDIO;
        //try to find a output format
        if (track->DecodedFormat(&fmt) == B_OK) {
                memcpy(&fFormat, &fmt.u.raw_audio, sizeof(fFormat));
                fMediaTrack = track;
                return;
        }

        //try again
        fmt.u.raw_audio.buffer_size = 2 * 4096;
        fmt.u.raw_audio.format = media_raw_audio_format::B_AUDIO_FLOAT;
        if (track->DecodedFormat(&fmt) == B_OK) {
                memcpy(&fFormat, &fmt.u.raw_audio, sizeof(fFormat));
                fMediaTrack = track;
                return;
        }

        //try again
        fmt.u.raw_audio.buffer_size = 4096;
        fmt.u.raw_audio.format = media_raw_audio_format::B_AUDIO_SHORT;
        if (track->DecodedFormat(&fmt) == B_OK) {
                memcpy(&fFormat, &fmt.u.raw_audio, sizeof(fFormat));
                fMediaTrack = track;
                return;
        }

        //we have failed
        ERROR("BTrackReader::SetToTrack failed\n");
}


BTrackReader::~BTrackReader()
{
        CALLED();
        if (fMediaFile && fMediaTrack)
                fMediaFile->ReleaseTrack(fMediaTrack);
        delete fMediaFile;
        delete[] fBuffer;
}


status_t
BTrackReader::InitCheck()
{
        CALLED();
        return fMediaTrack ? fMediaTrack->InitCheck() : B_ERROR;
}


int64 
BTrackReader::CountFrames(void)
{
        CALLED();
        return fMediaTrack ? fMediaTrack->CountFrames() : 0;
}


const media_raw_audio_format & 
BTrackReader::Format(void) const
{
        CALLED();
        return fFormat;
}


int32 
BTrackReader::FrameSize(void)
{
        CALLED();
        return fFrameSize;
}


status_t 
BTrackReader::ReadFrames(void* in_buffer, int32 frame_count)
{
        CALLED();

        uint8* buffer = static_cast<uint8*>(in_buffer);
        int32 bytes_to_read = frame_count * fFrameSize;

        status_t last_status = B_OK;
        while (bytes_to_read > 0) {
                int32 bytes_to_copy = min_c(fBufferUsedSize, bytes_to_read);
                if (bytes_to_copy > 0) {
                        memcpy(buffer, fBuffer + fBufferOffset, bytes_to_copy);
                        buffer += bytes_to_copy;
                        bytes_to_read -= bytes_to_copy;
                        fBufferOffset += bytes_to_copy;
                        fBufferUsedSize -= bytes_to_copy;
                }
                if (last_status != B_OK)
                        break;
                if (fBufferUsedSize == 0) {
                        int64 outFrameCount;
                        last_status = fMediaTrack->ReadFrames(fBuffer,
                                &outFrameCount);
                        fBufferOffset = 0;
                        fBufferUsedSize = outFrameCount * fFrameSize;
                }
        }
        if (bytes_to_read > 0) {
                memset(buffer, 0, bytes_to_read);
                return B_LAST_BUFFER_ERROR;
        }
        return B_OK;
}


status_t 
BTrackReader::SeekToFrame(int64* in_out_frame)
{
        CALLED();
        status_t s = fMediaTrack->SeekToFrame(in_out_frame, B_MEDIA_SEEK_CLOSEST_BACKWARD);
        if (s != B_OK)
                return s;
        fBufferUsedSize = 0;
        fBufferOffset = 0;
        return B_OK;
}


BMediaTrack* 
BTrackReader::Track(void)
{
        CALLED();
        return fMediaTrack;
}

}; //namespace BPrivate