path: root/src/mov_encoder_writer.cc

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/***************************************************************************
 *            mov_encoder_writer.cc
 *
 *  Sun May 22 12:51:36 CEST 2005
 *  Copyright  2005 Bent Bisballe
 *  deva@aasimon.org
 ****************************************************************************/

/*
 *    This file is part of MIaV.
 *
 *    MIaV is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    MIaV is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with MIaV; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */

/*
 * $Id$
 */

/*
 * $Log$
 * Revision 1.9  2005/07/05 23:15:16  deva
 * *** empty log message ***
 *
 * Revision 1.8  2005/06/30 10:04:35  deva
 * *** empty log message ***
 *
 * Revision 1.7  2005/06/19 20:04:43  deva
 * ImgEncoder now uses the file class for output, through jpeg_mem_dest.
 *
 * Revision 1.6  2005/06/16 21:28:57  deva
 * Rewrote thread object
 * Fixed bug in mov_encoder (pushed read_sem too many times, whihc lead to
 * growing server queue)
 *
 * Revision 1.5  2005/06/14 18:58:35  deva
 * *** empty log message ***
 *
 * Revision 1.4  2005/06/14 12:29:40  deva
 * Incorporated the use of the Info object everywhere... also using the log functionality.
 *
 * Revision 1.3  2005/05/26 21:32:39  deva
 * *** empty log message ***
 *
 * Revision 1.2  2005/05/26 12:48:36  deva
 * *** empty log message ***
 *
 * Revision 1.1  2005/05/22 15:49:22  deva
 * Added multithreaded encoding support.
 *
 */
#include <config.h>
#include "mov_encoder_writer.h"

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include <pthread.h>
#include <semaphore.h>

#include <errno.h>

#include <string>
using namespace std;

#include "miav_config.h"

#include <time.h>

MovEncoderWriter::MovEncoderWriter(const char* cpr, 
                                   FramePriorityQueue *q, 
                                   sem_t *s,
                                   pthread_mutex_t *m, 
                                   Info *i)
{
  info = i;
  info->info("MovEncoderWriter");

  // Create path and filename
  char fname[256];
  string *server_root;
  char birthmonth[3];
  char date[32];

  // Get server root
  server_root = config->readString("server_movie_root");

  // Copy the bytes representing the birth month from the cpr
  // [dd][mm][yy]-[nn][nn]
  strncpy(birthmonth, &cpr[2], 2);
  birthmonth[2] = 0;

  // Create date (today) in [yyyy][mm][dd]
  struct tm *ltime;
  time_t t = time(NULL);
  ltime = localtime(&t);
  sprintf(date, "%.4d%.2d%.2d", 
          ltime->tm_year + 1900, 
          ltime->tm_mon, 
          ltime->tm_mday);

  sprintf(fname, "%s/%s/%s/%s-%s-", server_root->c_str(), birthmonth, cpr, cpr, date);

  file = new File(fname, "mpg", info);

  sem = s;
  queue = q;
  frame_number = 0;
  mutex = m;

  running = true;
}

MovEncoderWriter::~MovEncoderWriter()
{
  info->info("~MovEncoderWriter");
  delete file;
}

void MovEncoderWriter::thread_main()
{
  info->info("MovEncoderWriter::run");

  Frame *frame;

  write_multiplex_header();

  while(running) {
    sem_wait(sem);

    // Lock output mutex
    pthread_mutex_lock(mutex);
    frame = queue->top();
    if(frame && frame->number == frame_number) queue->pop();
    //    poolsize = queue->size();
    pthread_mutex_unlock(mutex);
    // Unlock output mutex

    int wrote = 0;
    while(frame && (frame->number == frame_number)) {
      
      int ret = 0;

      ret = file->Write(frame->data, frame->size);
      frame_number++;
      wrote ++;

      delete frame;

      if(ret == -1) {
        info->error("File write returned -1.");
        return;
      }
      
      // Lock output mutex
      pthread_mutex_lock(mutex);
      frame = queue->top();
      if(frame && frame->number == frame_number) queue->pop();
      //      poolsize = queue->size();
      pthread_mutex_unlock(mutex);
      // Unlock output mutex
    }
  }

  info->info("MovEncoderWriter::stop");
}


/**
 *  Byte#      Data                Details
 *  ===================================================================
 *  1-4        Sequence header     In Hex 000001B3
 *             code
 *  12 bits    Horizontal size     In pixels
 *  12 bits    Vertical size       In pixels
 *   4 bits    Pel aspect ratio    See below
 *  18 bits    Frame rate          See below
 *   1 bit     Marker bit          Always 1
 *  10 bits    VBV buffer size     Minimum buffer needed to decode this
 *                                 sequence of pictures; in 16KB units
 *   1 bit     Constrained
 *             parameter flag
 *   1 bit     Load intra          0: false; 1: true (matrix follows)
 *             quantizer matrix
 *  64 bytes   Intra quantizer     Optional
 *             matrix
 *   1 bit     Load nonintra       0: false; 1: true (matrix follows)
 *             quantizer matrix
 *  64 bytes   Nonintra quantizer  Optional
 *             matrix
 *   -         Squence extension   Optional
 *             Data
 *   -         User data           Optional application-dependent data
 *  ===================================================================
 */
/**
 *  Pel aspect ratio:
 *  The actual height of a 12 pixels wide area (normal is 12 = square)
 *   Aspect Ratio (from http://homepage.mac.com/rnc/EditMpegHeaderIFO.html)
 *   1 = 1:1
 *   2 = 4:3
 *   3 = 16:9
 *   4 = 2.211 (not used in dvd)
 *  12 = unknown (or undefined!)
 */

/**
 *  Frame rates:
 *  1 = 23.976 frames/sec
 *  2 = 24
 *  3 = 25
 *  4 = 29.97
 *  5 = 30
 *  6 = 50
 *  7 = 59.94
 *  8 = 60
 */
void MovEncoderWriter::write_video_header()
{
  char header[] = {
    0x00, 0x00, 0x01, 0xB3, // Header
    0x2D, 0x02, 0x40, // 12 bits width, 12 bits height - 720 (hex: 2D0) x 576 (hex: 240)
    0x23, // 4 bits aspect (12 (hex C) works!) 4 bits frameratecode - 3 := 25fps (hex: 3)
    0x00, 0x00, // Bitrate - 0 (hex : 0)
    0x20, 0xA5, 0x10, 0x12, 0x12, 0x14,
    0x14, 0x14, 0x16, 0x16, 0x16, 0x16, 0x18, 0x18, 0x19, 0x18, 0x18, 0x1A, 0x1B, 0x1B, 0x1B, 0x1B,
    0x1A, 0x1C, 0x1D, 0x1E, 0x1E, 0x1E, 0x1D, 0x1C, 0x1E, 0x1F, 0x20, 0x21, 0x21, 0x20, 0x1F, 0x1E,
    0x21, 0x23, 0x23, 0x24, 0x23, 0x23, 0x21, 0x25, 0x26, 0x27, 0x27, 0x26, 0x25, 0x29, 0x2A, 0x2A,
    0x2A, 0x29, 0x2D, 0x2D, 0x2D, 0x2D, 0x30, 0x31, 0x30, 0x34, 0x34, 0x38, 0x16, 0x00, 0xF0, 0xC4,
    0x00, 0x00, 0x01, 0xB8, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0A, 0x72, 0x00,
    0x00, 0x00, 0x01, 0x01, 0x13, 0xF9, 0x50, 0x02, 0xBC, 0xB2, 0xB8, 0xBE, 0x68, 0x8B, 0xA4, 0x9F,
    0xC5, 0xB5, 0xCA, 0x00, 0x56, 0x76, 0x39, 0x65, 0xF2, 0x30, 0x8B, 0xA6, 0x9D, 0x50, 0x69, 0xE7,
    0xDA, 0xFE, 0x13, 0xCF, 0xB7, 0xFF, 0x8F, 0xF4, 0xCE, 0x7B, 0xFA, 0x0E, 0xF0, 0x66, 0xAE, 0x1C,
    0x5D, 0xE7, 0x00, 0xC8, 0x0A, 0x92, 0xB9, 0x29, 0x3C, 0x21, 0x23, 0xF1, 0xD6, 0x40, 0x13, 0x06,
    0xF0, 0x10, 0x10, 0xC6, 0x27, 0x80, 0xA0, 0x34, 0xE1, 0xC8, 0xE4, 0x0F, 0x74, 0x91, 0xDA, 0xC4,
    0x03, 0xA0, 0xDC, 0x03, 0x12, 0x60, 0x18, 0x49, 0x27, 0x1D, 0xD4, 0xBC, 0x67, 0x0E, 0x54, 0x8C,
    0x96, 0xFC, 0x5D, 0xC0, 0x06, 0xE0, 0x1A, 0x72, 0x11, 0x7C, 0x9A, 0x8D, 0xC9, 0x45, 0x89, 0x6D,
    0xCD, 0xC4, 0x0B, 0x63, 0xDC, 0x90, 0x18, 0x24, 0x00, 0xEC, 0x84, 0x90, 0x18, 0x10, 0xC9, 0x3B,
    0x1E, 0xA7, 0x60, 0x3C, 0x9D, 0x74, 0x80, 0x76, 0x05, 0x0B, 0x02, 0x81, 0xA9, 0x29, 0x39, 0x68,
    0x53, 0x8F, 0x59, 0xF1, 0xBF, 0x93, 0xFB, 0xA0, 0x04, 0x01, 0xBC, 0xB0, 0xCE, 0x18, 0xE1, 0x25
  };

  file->Write(header, sizeof(header));

  
}
/*
4449 0433 0000 0000
*/
void MovEncoderWriter::write_audio_header()
{
  char header[] = {
    0x44, 0x49, 0x04, 0x33, 
    0x00, 0x00, 0x00, 0x00
  };

  file->Write(header, sizeof(header));
}

void MovEncoderWriter::write_multiplex_header()
{
  char header[] = {
    0x00, 0x00, 0xba, 0x01, 
    0x00, 
    0x21, 0x00, 0x01, 0x80, 0x19, 0x8d, 0x0a, 
    0x00, 0x00, 0xbb, 0x01,
    0x0c, 0x00, 0x0a, 0x80, 0x06, 0x8d, 0xff, 0xe1, 0xe0, 0xe0, 0xc0, 0x25, 0x20, 0xc0a, 0x00, 0x00,
    0xba, 0x01, 0x00, 0x21, 0x15, 0x01, 0x80, 0x6d, 0x8d, 0x0a
    /*
    0x00, 0x00, 0xe0, 0x01a, 0x3d, 0x04,
    0x25, 0x60, 0x00, 0x31, 0xd7, 0x03, 0x11, 0x8f, 0x03, 0x00, 0x19, 0xc0, 0x00, 0x00a, 0xb3, 0x01,
    0x00, 0x16, 0xc4, 0xf0, 0x38, 0x01, 0x85, 0xa0, 0x11, 0x10, 0x12, 0x11, 0x12, 0x12a, 0x13, 0x13,
    0x13, 0x13, 0x14, 0x14, 0x14, 0x14, 0x15, 0x14, 0x15, 0x15, 0x15, 0x15, 0x16, 0x15a, 0x16, 0x16,
    0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x18, 0x18a, 0x19, 0x18,
    0x18, 0x18, 0x19, 0x18, 0x1a, 0x1a, 0x1a, 0x1a, 0x1b, 0x19, 0x1b, 0x1b, 0x1b, 0x1ba, 0x1c, 0x1c,
    0x1c, 0x1c, 0x1e, 0x1e, 0x1f, 0x1e, 0x21, 0x1f, 0x00, 0x00, 0xb2, 0x01, 0x87, 0x00a, 0x00, 0x81,
    0x65, 0x26, 0x63, 0x6e, 0x64, 0x6f, 0x64, 0x65, 0x62, 0x20, 0x20, 0x79, 0x4d, 0x54a, 0x47, 0x50,
    0x6e, 0x45, 0x20, 0x63, 0x76, 0x28, 0x72, 0x65, 0x20, 0x2e, 0x2e, 0x32, 0x32, 0x35a, 0x2e, 0x31,
    0x38, 0x35, 0x31, 0x2e, 0x39, 0x36, 0x00, 0x29, 0x00, 0x00, 0xb8, 0x01, 0xab, 0x00a, 0x20, 0x22,
    0x00, 0x00, 0x00, 0x01, 0x8d, 0x00, 0x78, 0x09, 0x00, 0x00, 0x01, 0x01, 0xf9, 0x1ba, 0x20, 0xf8,
    0x02, 0x5e, 0xa1, 0x18, 0x11, 0x30, 0x70, 0xfe, 0xd3, 0x00, 0x4c, 0xdf, 0x84, 0x02a, 0x30, 0xd0,
    0x9e, 0x5b, 0x77, 0x81, 0x41, 0xcc, 0xf4, 0x02, 0xc5, 0x10, 0x40, 0x08, 0xf3, 0x8fa, 0x06, 0x80,
    0xfa, 0x9e, 0xe7, 0x95, 0x3c, 0x80, 0x09, 0xc1, 0x20, 0xbd, 0xbf, 0x07, 0xd0, 0xe2a, 0xaa, 0x62
    */
  };

  file->Write(header, sizeof(header));
}