/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this file,

 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "OggWriter.h"

#include "prtime.h"

#include "GeckoProfiler.h"

#undef LOG

#define LOG(args, ...)

namespace mozilla {

OggWriter::OggWriter()

  : ContainerWriter()

  , mOggStreamState()

  , mOggPage()

  , mPacket()

{

  if (NS_FAILED(Init())) {

    LOG("ERROR! Fail to initialize the OggWriter.");

  }

}

OggWriter::~OggWriter()

{

  if (mInitialized) {

    ogg_stream_clear(&mOggStreamState);

  }

  // mPacket's data was always owned by us, no need to ogg_packet_clear.

}

nsresult

OggWriter::Init()

{

  MOZ_ASSERT(!mInitialized);

  // The serial number (serialno) should be a random number, for the current

  // implementation where the output file contains only a single stream, this

  // serialno is used to differentiate between files.

  srand(static_cast<unsigned>(PR_Now()));

  int rc = ogg_stream_init(&mOggStreamState, rand());

  mPacket.b_o_s = 1;

  mPacket.e_o_s = 0;

  mPacket.granulepos = 0;

  mPacket.packet = nullptr;

  mPacket.packetno = 0;

  mPacket.bytes = 0;

  mInitialized = (rc == 0);

  return (rc == 0) ? NS_OK : NS_ERROR_NOT_INITIALIZED;

}

nsresult

OggWriter::WriteEncodedTrack(const EncodedFrameContainer& aData,

                             uint32_t aFlags)

{

  AUTO_PROFILER_LABEL("OggWriter::WriteEncodedTrack", OTHER);

  uint32_t len = aData.GetEncodedFrames().Length();

  for (uint32_t i = 0; i < len; i++) {

    if (aData.GetEncodedFrames()[i]->GetFrameType() != EncodedFrame::OPUS_AUDIO_FRAME) {

      LOG("[OggWriter] wrong encoded data type!");

      return NS_ERROR_FAILURE;

    }

    // only pass END_OF_STREAM on the last frame!

    nsresult rv = WriteEncodedData(aData.GetEncodedFrames()[i]->GetFrameData(),

                                   aData.GetEncodedFrames()[i]->GetDuration(),

                                   i < len-1 ? (aFlags & ~ContainerWriter::END_OF_STREAM) :

                                   aFlags);

    if (NS_FAILED(rv)) {

      LOG("%p Failed to WriteEncodedTrack!", this);

      return rv;

    }

  }

  return NS_OK;

}

nsresult

OggWriter::WriteEncodedData(const nsTArray<uint8_t>& aBuffer, int aDuration,

                            uint32_t aFlags)

{

  if (!mInitialized) {

    LOG("[OggWriter] OggWriter has not initialized!");

    return NS_ERROR_FAILURE;

  }

  MOZ_ASSERT(!ogg_stream_eos(&mOggStreamState),

             "No data can be written after eos has marked.");

  // Set eos flag to true, and once the eos is written to a packet, there must

  // not be anymore pages after a page has marked as eos.

  if (aFlags & ContainerWriter::END_OF_STREAM) {

    LOG("[OggWriter] Set e_o_s flag to true.");

    mPacket.e_o_s = 1;

  }

  mPacket.packet = const_cast<uint8_t*>(aBuffer.Elements());

  mPacket.bytes = aBuffer.Length();

  mPacket.granulepos += aDuration;

  // 0 returned on success. -1 returned in the event of internal error.

  // The data in the packet is copied into the internal storage managed by the

  // mOggStreamState, so we are free to alter the contents of mPacket after

  // this call has returned.

  int rc = ogg_stream_packetin(&mOggStreamState, &mPacket);

  if (rc < 0) {

    LOG("[OggWriter] Failed in ogg_stream_packetin! (%d).", rc);

    return NS_ERROR_FAILURE;

  }

  if (mPacket.b_o_s) {

    mPacket.b_o_s = 0;

  }

  mPacket.packetno++;

  mPacket.packet = nullptr;

  return NS_OK;

}

void

OggWriter::ProduceOggPage(nsTArray<nsTArray<uint8_t> >* aOutputBufs)

{

  aOutputBufs->AppendElement();

  aOutputBufs->LastElement().SetLength(mOggPage.header_len +

                                       mOggPage.body_len);

  memcpy(aOutputBufs->LastElement().Elements(), mOggPage.header,

         mOggPage.header_len);

  memcpy(aOutputBufs->LastElement().Elements() + mOggPage.header_len,

         mOggPage.body, mOggPage.body_len);

}

nsresult

OggWriter::GetContainerData(nsTArray<nsTArray<uint8_t> >* aOutputBufs,

                            uint32_t aFlags)

{

  int rc = -1;

  AUTO_PROFILER_LABEL("OggWriter::GetContainerData", OTHER);

  // Generate the oggOpus Header

  if (aFlags & ContainerWriter::GET_HEADER) {

    OpusMetadata* meta = static_cast<OpusMetadata*>(mMetadata.get());

    NS_ASSERTION(meta, "should have meta data");

    NS_ASSERTION(meta->GetKind() == TrackMetadataBase::METADATA_OPUS,

                 "should have Opus meta data");

    nsresult rv = WriteEncodedData(meta->mIdHeader, 0);

    NS_ENSURE_SUCCESS(rv, rv);

    rc = ogg_stream_flush(&mOggStreamState, &mOggPage);

    NS_ENSURE_TRUE(rc > 0, NS_ERROR_FAILURE);

    ProduceOggPage(aOutputBufs);

    rv = WriteEncodedData(meta->mCommentHeader, 0);

    NS_ENSURE_SUCCESS(rv, rv);

    rc = ogg_stream_flush(&mOggStreamState, &mOggPage);

    NS_ENSURE_TRUE(rc > 0, NS_ERROR_FAILURE);

    ProduceOggPage(aOutputBufs);

    return NS_OK;

  // Force generate a page even if the amount of packet data is not enough.

  // Usually do so after a header packet.

  } else if (aFlags & ContainerWriter::FLUSH_NEEDED) {

    // rc = 0 means no packet to put into a page, or an internal error.

    rc = ogg_stream_flush(&mOggStreamState, &mOggPage);

  } else {

    // rc = 0 means insufficient data has accumulated to fill a page, or an

    // internal error has occurred.

    rc = ogg_stream_pageout(&mOggStreamState, &mOggPage);

  }

  if (rc) {

    ProduceOggPage(aOutputBufs);

  }

  if (aFlags & ContainerWriter::FLUSH_NEEDED) {

    mIsWritingComplete = true;

  }

  return (rc > 0) ? NS_OK : NS_ERROR_FAILURE;

}

nsresult

OggWriter::SetMetadata(TrackMetadataBase* aMetadata)

{

  MOZ_ASSERT(aMetadata);

  AUTO_PROFILER_LABEL("OggWriter::SetMetadata", OTHER);

  if (aMetadata->GetKind() != TrackMetadataBase::METADATA_OPUS) {

    LOG("wrong meta data type!");

    return NS_ERROR_FAILURE;

  }

  // Validate each field of METADATA

  mMetadata = static_cast<OpusMetadata*>(aMetadata);

  if (mMetadata->mIdHeader.Length() == 0) {

    LOG("miss mIdHeader!");

    return NS_ERROR_FAILURE;

  }

  if (mMetadata->mCommentHeader.Length() == 0) {

    LOG("miss mCommentHeader!");

    return NS_ERROR_FAILURE;

  }

  return NS_OK;

}

} // namespace mozilla