/*
 * transfer.c: Transfer mode
 *
 * See the main source file 'vdr.c' for copyright information and
 * how to reach the author.
 *
 * $Id: transfer.c 1.30 2005/08/14 10:55:03 kls Exp $
 */

#include "transfer.h"
#include "videodir.h"
#include "menu.h"
#include "vdrttxtsubshooks.h"
#include "dvbsub.h"

#define TRANSFERBUFSIZE  MEGABYTE(2)
#define POLLTIMEOUTS_BEFORE_DEVICECLEAR 6

// --- cTransfer -------------------------------------------------------------

cTransfer::cTransfer(int VPid, const int *APids, const int *DPids, const int *SPids)
:cReceiver(0, -1, VPid, APids, Setup.UseDolbyDigital ? DPids : NULL, SPids)
,cThread("transfer")
{
  ringBuffer = new cRingBufferLinear(TRANSFERBUFSIZE, TS_SIZE * 2, true, "Transfer");
  remux = new cRemux(VPid, APids, Setup.UseDolbyDigital ? DPids : NULL, SPids);
  needsBufferReserve = Setup.UseDolbyDigital && VPid != 0 && DPids && DPids[0] != 0;
}

cTransfer::~cTransfer()
{
  cReceiver::Detach();
  cPlayer::Detach();
  delete remux;
  delete ringBuffer;
}

void cTransfer::Activate(bool On)
{
  if (On)
     Start();
  else
     Cancel(3);
}

void cTransfer::Receive(uchar *Data, int Length)
{
  if (IsAttached() && Running()) {
     int p = ringBuffer->Put(Data, Length);
     if (p != Length && Running())
        ringBuffer->ReportOverflow(Length - p);
     return;
     }
}

#define FW_NEEDS_BUFFER_RESERVE_FOR_AC3
#ifdef FW_NEEDS_BUFFER_RESERVE_FOR_AC3
//XXX This is a very ugly hack to allow cDvbOsd to reduce the buffer
//XXX requirements in cTransfer if it detects a 4MB full featured DVB card.
bool DvbCardWith4MBofSDRAM = false;
#endif

void cTransfer::Action(void)
{
  int PollTimeouts = 0;
  uchar *p = NULL;
  int Result = 0;
#ifdef FW_NEEDS_BUFFER_RESERVE_FOR_AC3
  bool GotBufferReserve = false;
  int RequiredBufferReserve = KILOBYTE(DvbCardWith4MBofSDRAM ? 288 : 576);
#endif
  while (Running()) {
#ifdef FW_NEEDS_BUFFER_RESERVE_FOR_AC3
        if (needsBufferReserve && !GotBufferReserve) {
           //XXX For dolby we've to fill the buffer because the firmware does
           //XXX not decode dolby but use a PCM stream for transport, therefore
           //XXX the firmware has not enough buffer for noiseless skipping early
           //XXX PCM samples (each dolby frame requires 6144 bytes in PCM and
           //XXX audio is mostly to early in comparison to video).
           //XXX To resolve this, the remuxer or PlayPes() should synchronize
           //XXX audio with the video frames. 2004/09/09 Werner
           if (ringBuffer->Available() < RequiredBufferReserve) { // used to be MAXFRAMESIZE, but the HDTV value of KILOBYTE(512) is way too much here
              cCondWait::SleepMs(20); // allow the buffer to collect some reserve
              continue;
              }
           else
              GotBufferReserve = true;
           }
#endif
        int Count;
        uchar *b = ringBuffer->Get(Count);
        if (b) {
           if (ringBuffer->Available() > TRANSFERBUFSIZE * 9 / 10) {
              // If the buffer runs full, we have no chance of ever catching up
              // since the data comes in at the same rate as it goes out (it's "live").
              // So let's clear the buffer instead of suffering from permanent
              // overflows.
              dsyslog("clearing transfer buffer to avoid overflows");
              DeviceClear();
              ringBuffer->Clear();
              remux->Clear();
              PlayPes(NULL, 0);
              p = NULL;
#ifdef FW_NEEDS_BUFFER_RESERVE_FOR_AC3
              GotBufferReserve = false;
#endif
              continue;
              }
           Count = remux->Put(b, Count);
           if (Count)
              ringBuffer->Del(Count);
           }
        if (!p)
           p = remux->Get(Result);
        if (p) {
           cPoller Poller;
           if (DevicePoll(Poller, 100)) {
              PollTimeouts = 0;
              int w = PlayPes(p, Result);
              if (w > 0) {
                 p += w;
                 Result -= w;
                 remux->Del(w);
                 if (Result <= 0)
                    p = NULL;
                 }
              else if (w < 0 && FATALERRNO)
                 LOG_ERROR;
              }
           else {
              PollTimeouts++;
              if (PollTimeouts == POLLTIMEOUTS_BEFORE_DEVICECLEAR) {
                 dsyslog("clearing device because of consecutive poll timeouts");
                 DeviceClear();
                 ringBuffer->Clear();
                 remux->Clear();
                 PlayPes(NULL, 0);
                 p = NULL;
#ifdef FW_NEEDS_BUFFER_RESERVE_FOR_AC3
                 GotBufferReserve = false;
#endif
                 }
              }
           }
        }
}

// --- cLiveRecorder ---------------------------------------------------------

cLiveRecorder *cLiveRecorderControl::liveRecorder[MAXLIVERECORDERS] = {NULL};
cLiveRecorder *cLiveRecorder::ActiveLiveRecorder = NULL;
cLiveRecorderControl *cLiveRecorderControl::LiveThread = NULL;

cLiveRecorder::cLiveRecorder(cDevice *ReceiverDevice, const cChannel *Channel)
{
  start = time(NULL);
  New = true;
  receiverDevice = ReceiverDevice;
  channelID = tChannelID::tChannelID(Channel->Source(),Channel->Nid(),Channel->Tid(),Channel->Sid(),Channel->Rid());
  Pids.VPid=Channel->Vpid();
  for (int i=0; i<=MAXAPIDS; i++) 
     Pids.APids[i] = Channel->Apid(i);
  for (int i=0; i<=MAXDPIDS; i++)
     Pids.DPids[i] = Channel->Dpid(i);
  for (int i=0; i<=MAXSPIDS; i++)
     Pids.SPids[i] = Channel->Spid(i);
  Rew=false;
  sprintf(FileName,"%s/LiveBuffer/%s",BufferDirectory,Channel->Name());
  while (DirectoryOk(FileName,false))
    sprintf(FileName,"%s_",FileName);
  MakeDirs(FileName,true);
  cTtxtSubsRecorderBase *subsRecorder = cVDRTtxtsubsHookListener::Hook()->NewTtxtSubsRecorder(receiverDevice, Channel);
  int SubPids[3] = {DvbSubtitlesRecording.GetPidByChannel(receiverDevice->DeviceNumber(), Channel, 1), DvbSubtitlesRecording.GetPidByChannel(receiverDevice->DeviceNumber(), Channel, 2), 0};
  Recorder=new cRecorder(FileName, 0, -1,Channel->Vpid(), Channel->Apids(), Channel->Dpids(), SubPids, subsRecorder, true);
  if (subsRecorder) subsRecorder->DeviceAttach();
  while (!cLiveRecorderControl::LiveThread->wantadd && !ReceiverDevice->HasLock())
    usleep(100);
  if (!cLiveRecorderControl::LiveThread->wantadd)
  {
    ReceiverDevice->AttachReceiver(Recorder);
    attached = true;
  }
  while (cControl::Control() && !cControl::Control()->Attached() && !cLiveRecorderControl::LiveThread->wantadd)
    usleep(100);
  cReplayControl::SetRecording(FileName,"LiveBuffer");
  replay=NULL;
  if (cDevice::PrimaryDevice()->Replaying() && !cControl::Control())
    return;
  if (!cLiveRecorderControl::LiveThread->wantadd)
   cControl::Launch(replay = new cReplayControl(true,this));
}

cLiveRecorder::~cLiveRecorder()
{
  delete Recorder;
  RemoveFileOrDir(FileName,true);
}

bool cLiveRecorder::PIDsChanged(const cChannel *Channel)
{
  bool changed=false;
  if (Pids.VPid != Channel->Vpid())
    changed=true;
  Pids.VPid=Channel->Vpid();
  for (int i=0; i<=MAXAPIDS; i++)
  {
    if (Pids.APids[i] != Channel->Apid(i))
      changed=true;
    Pids.APids[i]=Channel->Apid(i);
  }
  for (int i=0; i<=MAXDPIDS; i++)
  {
    if (Pids.DPids[i] != Channel->Dpid(i))
      changed=true;
    Pids.DPids[i]=Channel->Dpid(i);
  }
  for (int i=0; i<=MAXSPIDS; i++)
  {
    if (Pids.SPids[i] != Channel->Spid(i))
      changed=true;
    Pids.SPids[i]=Channel->Spid(i);
  }
  return changed;
}

void cLiveRecorder::DetachReceiver()
  {
  receiverDevice->Detach(Recorder);
  attached = false;
}

void cLiveRecorder::rew(bool On)
{
  if (!Setup.KeepBuffer)
    return;
  if (!On)
    Recorder->priority = -1; 
  Rew=On;
  replay->Rew(On);
}

bool cLiveRecorder::IsAlreadyRecording(tChannelID ChannelID)
{
  return channelID==ChannelID;
}

void cLiveRecorder::Resume()
  {
  cControl::Shutdown();
  cReplayControl::SetRecording(FileName,"LiveBuffer");
  cControl::Launch(replay = new cReplayControl(true,this));
  if (Recorder->priority != -2)
      {
    Recorder->priority = -1;
    New = true;
  }
  if (Rew)
    replay->Rew(true);
}

// --- cLiveRecorderControl --------------------------------------------------

cLiveRecorderControl::cLiveRecorderControl()
{
  wantadd=false;
  add=false;
  Start();
}

void cLiveRecorderControl::ClearBufferDirectory()
{
  char FileName[255];
  sprintf(FileName,"%s/LiveBuffer",BufferDirectory);
  cReadDir d(FileName);
  struct dirent *e;
  while ((e=d.Next()) != NULL) {
     if (strcmp(e->d_name, ".") && strcmp(e->d_name, "..")) {
        char *buffer;
        asprintf(&buffer, "%s/%s", FileName, e->d_name);
        RemoveFileOrDir(buffer,true);
        }
     }
}

void cLiveRecorderControl::Action()
{
  ClearBufferDirectory();
  while (Running())
  {
   if (!add)
    {
      wantadd=false;
      usleep(100);
      continue;
    }
    cLiveRecorder *OldRecorder=NULL,*OldActive=cLiveRecorder::ActiveLiveRecorder;
    cLiveRecorder::ActiveLiveRecorder=NULL;
    for (int i=0; i<MAXLIVERECORDERS; i++)
    {
      if (liveRecorder[i]) 
      {
        if (!liveRecorder[i]->attached || (!liveRecorder[i]->IsAlreadyRecording(tChannelID::tChannelID(Channel->Source(),Channel->Nid(),Channel->Tid(),Channel->Sid(),Channel->Rid())) && liveRecorder[i]->Recorder->priority==-1))
      {
      if (!OldRecorder && !liveRecorder[i]->IsAlreadyRecording(tChannelID::tChannelID(Channel->Source(),Channel->Nid(),Channel->Tid(),Channel->Sid(),Channel->Rid())))
          OldRecorder=liveRecorder[i];
        else
          delete liveRecorder[i];
        liveRecorder[i]=NULL;
      }
      }
      if (liveRecorder[i] && liveRecorder[i]->IsAlreadyRecording(tChannelID::tChannelID(Channel->Source(),Channel->Nid(),Channel->Tid(),Channel->Sid(),Channel->Rid())))
        cLiveRecorder::ActiveLiveRecorder = liveRecorder[i];
    }
    if (cLiveRecorder::ActiveLiveRecorder)
    {
      if (cLiveRecorder::ActiveLiveRecorder->PIDsChanged(Channel))
        cLiveRecorder::ActiveLiveRecorder->Recorder->ChangePIDs(ReceiverDevice,Channel->Vpid(), Channel->Apids(),Channel->Dpids(),Channel->Spids());
      if (cLiveRecorder::ActiveLiveRecorder != OldActive || !OldActive->replay || !cDevice::PrimaryDevice()->Replaying())
      cLiveRecorder::ActiveLiveRecorder->Resume();
	}
    else
    {
      int i;
      for (i=0; i<MAXLIVERECORDERS; i++)
        if (!liveRecorder[i])
        {
          cLiveRecorder::ActiveLiveRecorder = liveRecorder[i] = new cLiveRecorder(ReceiverDevice, Channel);
          break;
        } 
      if (i==MAXLIVERECORDERS)
      {
        delete liveRecorder[0];
        cLiveRecorder::ActiveLiveRecorder = liveRecorder[1] = new cLiveRecorder(ReceiverDevice, Channel);
      }
    }
    if (OldRecorder)
      delete OldRecorder;
    cTransferControl::receiverDevice = ReceiverDevice;
    add=false;
  }
  for (int i=0; i<MAXLIVERECORDERS; i++)
    if (liveRecorder[i])
    {
      delete liveRecorder[i];
      liveRecorder[i]=NULL;
    }
  cTransferControl::receiverDevice = NULL;
  cLiveRecorder::ActiveLiveRecorder=NULL;
  ClearBufferDirectory();
}

void cLiveRecorderControl::Add(cDevice *ReceiverDevice, const cChannel *Channel)
{
  if (!LiveThread)
    LiveThread = new cLiveRecorderControl;
  LiveThread->wantadd=true;
  while (LiveThread->wantadd)
    usleep(10);
  LiveThread->ReceiverDevice=ReceiverDevice;
  LiveThread->Channel=Channel;
  LiveThread->add=true;
}

void cLiveRecorderControl::Shutdown()
{
  if (LiveThread)
    LiveThread->Cancel(3);
  LiveThread=NULL;
}

void cLiveRecorderControl::DetachReceivers(cDevice *Device)
{
  for (int i=0; i<MAXLIVERECORDERS; i++)
    if (liveRecorder[i] && liveRecorder[i]->receiverDevice == Device)
      liveRecorder[i]->DetachReceiver();
}

cLiveRecorder* cLiveRecorderControl::GetLiveRecorder(cChannel *Channel)
{
  if (Channel)
  {
    for (int i=0; i<MAXLIVERECORDERS; i++)
      if (liveRecorder[i] && liveRecorder[i]->IsAlreadyRecording(tChannelID::tChannelID(Channel->Source(),Channel->Nid(),Channel->Tid(),Channel->Sid(),Channel->Rid())))
      {
        return liveRecorder[i];
        break;
      }
    return NULL;
  }
  else
    return cLiveRecorder::ActiveLiveRecorder;
}

void cLiveRecorderControl::UpdateTimes()
{
  if (cControl::Control() && cControl::Control()->IsLiveRecording() && !LiveThread->add)
  {
    bool play,forward;
    int speed;
    cControl::Control()->GetReplayMode(play,forward,speed);
    if (!play && cLiveRecorder::ActiveLiveRecorder->Rew)
      cLiveRecorder::ActiveLiveRecorder->Recorder->priority=-2;
  }
  int l=-1;
  if (Setup.KeepLastBuffer)
    for (int i=0; i<MAXLIVERECORDERS; i++)
      if (liveRecorder[i] && liveRecorder[i]->Recorder->priority==-1 && liveRecorder[i]->New && time(NULL)-liveRecorder[i]->start > Setup.BufferTimeOut)
      {
        liveRecorder[i]->Recorder->priority = -3;
        liveRecorder[i]->New = false;
        l=i;
        break;
      }
  if (l>=0)
    for (int i=0; i<MAXLIVERECORDERS; i++)
      if (i!=l && liveRecorder[i])
        liveRecorder[i]->Recorder->priority=liveRecorder[i]->Recorder->priority < -2 ? liveRecorder[i]->Recorder->priority > -Setup.NumLastBuffers - 2 ? liveRecorder[i]->Recorder->priority - 1 : -1 : liveRecorder[i]->Recorder->priority;
}  

// --- cTransferControl ------------------------------------------------------

cDevice *cTransferControl::receiverDevice = NULL;

cTransferControl::cTransferControl(cDevice *ReceiverDevice, int VPid, const int *APids, const int *DPids, const int *SPids)
:cControl(transfer = new cTransfer(VPid, APids, DPids, SPids), true)

{
  ReceiverDevice->AttachReceiver(transfer);
  receiverDevice = ReceiverDevice;
}

cTransferControl::~cTransferControl()
{
  receiverDevice = NULL;
  delete transfer;
}
