stsdtable.c

这个库实现了录象功能

/*******************************************************************************
 stsdtable.c

 libquicktime - A library for reading and writing quicktime/avi/mp4 files.
 http://libquicktime.sourceforge.net

 Copyright (C) 2002 Heroine Virtual Ltd.
 Copyright (C) 2002-2007 Members of the libquicktime project.

 This library is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License as published by the Free
 Software Foundation; either version 2.1 of the License, or (at your option)
 any later version.

 This library 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 Lesser General Public License for more
 details.

 You should have received a copy of the GNU Lesser General Public License along
 with this library; if not, write to the Free Software Foundation, Inc., 51
 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*******************************************************************************/ 

#include "lqt_private.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define LOG_DOMAIN "stsdtable"

static void quicktime_stsdtable_read_text(quicktime_t *file,
                                          quicktime_stsd_table_t *table,
                                          quicktime_atom_t *parent_atom)
  {
  table->text.displayFlags = quicktime_read_int32(file);
  table->text.textJustification = quicktime_read_int32(file);

  table->text.bgColor[0] = quicktime_read_int16(file);
  table->text.bgColor[1] = quicktime_read_int16(file);
  table->text.bgColor[2] = quicktime_read_int16(file);

  table->text.defaultTextBox[0] = quicktime_read_int16(file);
  table->text.defaultTextBox[1] = quicktime_read_int16(file);
  table->text.defaultTextBox[2] = quicktime_read_int16(file);
  table->text.defaultTextBox[3] = quicktime_read_int16(file);

  table->text.scrpStartChar = quicktime_read_int32(file);

  table->text.scrpHeight = quicktime_read_int16(file);
  table->text.scrpAscent = quicktime_read_int16(file);
  table->text.scrpFont = quicktime_read_int16(file);
  table->text.scrpFace = quicktime_read_int16(file);
  table->text.scrpSize = quicktime_read_int16(file);
  
  table->text.scrpColor[0] = quicktime_read_int16(file);
  table->text.scrpColor[1] = quicktime_read_int16(file);
  table->text.scrpColor[2] = quicktime_read_int16(file);

  quicktime_read_pascal(file, table->text.font_name);
  }

static void quicktime_write_stsd_text(quicktime_t *file,
                                      quicktime_stsd_table_t *table)
  {
  quicktime_write_int32(file, table->text.displayFlags);
  quicktime_write_int32(file, table->text.textJustification);

  quicktime_write_int16(file, table->text.bgColor[0]);
  quicktime_write_int16(file, table->text.bgColor[1]);
  quicktime_write_int16(file, table->text.bgColor[2]);

  quicktime_write_int16(file, table->text.defaultTextBox[0]);
  quicktime_write_int16(file, table->text.defaultTextBox[1]);
  quicktime_write_int16(file, table->text.defaultTextBox[2]);
  quicktime_write_int16(file, table->text.defaultTextBox[3]);

  quicktime_write_int32(file, table->text.scrpStartChar);

  quicktime_write_int16(file, table->text.scrpHeight);
  quicktime_write_int16(file, table->text.scrpAscent);
  quicktime_write_int16(file, table->text.scrpFont);
  quicktime_write_int16(file, table->text.scrpFace);
  quicktime_write_int16(file, table->text.scrpSize);
  
  quicktime_write_int16(file, table->text.scrpColor[0]);
  quicktime_write_int16(file, table->text.scrpColor[1]);
  quicktime_write_int16(file, table->text.scrpColor[2]);

  quicktime_write_pascal(file, table->text.font_name);
  }

static void quicktime_stsdtable_dump_text(quicktime_stsd_table_t *table)
  {
  lqt_dump("       displayFlags      %08x\n", table->text.displayFlags);
  lqt_dump("       textJustification %d\n", table->text.textJustification);
  lqt_dump("       bgColor:          [%d,%d,%d]\n", table->text.bgColor[0],
           table->text.bgColor[1],table->text.bgColor[2]);
  lqt_dump("       defaultTextBox:   [%d,%d,%d,%d]\n",
           table->text.defaultTextBox[0],
           table->text.defaultTextBox[1],
           table->text.defaultTextBox[2],
           table->text.defaultTextBox[3]);
  lqt_dump("       scrpStartChar:    %d\n", table->text.scrpStartChar);
  lqt_dump("       scrpHeight:       %d\n", table->text.scrpHeight);
  lqt_dump("       scrpFont:         %d\n", table->text.scrpFont);
  lqt_dump("       scrpFace:         %d\n", table->text.scrpFace);
  lqt_dump("       scrpSize:         %d\n", table->text.scrpSize);
  lqt_dump("       scrpColor:        [%d,%d,%d]\n",
           table->text.scrpColor[0],
           table->text.scrpColor[1],
           table->text.scrpColor[2]);
  lqt_dump("       Font:             %s\n", table->text.font_name);
  }

static void
quicktime_stsdtable_read_tx3g(quicktime_t *file,
                              quicktime_stsd_table_t *table,
                              quicktime_atom_t *parent_atom)
  {
  quicktime_atom_t leaf_atom;
  table->tx3g.display_flags = quicktime_read_int32(file);
  quicktime_read_data(file, &table->tx3g.horizontal_justification, 1);
  quicktime_read_data(file, &table->tx3g.vertical_justification, 1);
  quicktime_read_data(file, table->tx3g.back_color, 4);
  table->tx3g.defaultTextBox[0] = quicktime_read_int16(file);
  table->tx3g.defaultTextBox[1] = quicktime_read_int16(file);
  table->tx3g.defaultTextBox[2] = quicktime_read_int16(file);
  table->tx3g.defaultTextBox[3] = quicktime_read_int16(file);
  table->tx3g.start_char_offset = quicktime_read_int16(file);
  table->tx3g.end_char_offset   = quicktime_read_int16(file);
  table->tx3g.font_id           = quicktime_read_int16(file);
  quicktime_read_data(file, &table->tx3g.style_flags, 1);
  quicktime_read_data(file, &table->tx3g.font_size, 1);
  quicktime_read_data(file, table->tx3g.text_color, 4);

  while(quicktime_position(file) < parent_atom->end)
    {
    quicktime_atom_read_header(file, &leaf_atom);
    if(quicktime_atom_is(&leaf_atom, "ftab"))
      {
      quicktime_read_ftab(file, &(table->tx3g.ftab));
      table->tx3g.has_ftab = 1;
      }
    else
      quicktime_atom_skip(file, &leaf_atom);
    }
  }

static void
quicktime_write_stsd_tx3g(quicktime_t *file,
                          quicktime_stsd_table_t *table)
  {
  quicktime_write_int32(file, table->tx3g.display_flags);
  quicktime_write_data(file, &table->tx3g.horizontal_justification, 1);
  quicktime_write_data(file, &table->tx3g.vertical_justification, 1);
  quicktime_write_data(file, table->tx3g.back_color, 4);
  quicktime_write_int16(file, table->tx3g.defaultTextBox[0]);
  quicktime_write_int16(file, table->tx3g.defaultTextBox[1]);
  quicktime_write_int16(file, table->tx3g.defaultTextBox[2]);
  quicktime_write_int16(file, table->tx3g.defaultTextBox[3]);
  quicktime_write_int16(file, table->tx3g.start_char_offset);
  quicktime_write_int16(file, table->tx3g.end_char_offset);
  quicktime_write_int16(file, table->tx3g.font_id);
  quicktime_write_data(file, &table->tx3g.style_flags, 1);
  quicktime_write_data(file, &table->tx3g.font_size, 1);
  quicktime_write_data(file, table->tx3g.text_color, 4);
  
  if(table->tx3g.has_ftab)
    quicktime_write_ftab(file, &table->tx3g.ftab);
  }

static void quicktime_stsdtable_dump_tx3g(quicktime_stsd_table_t *table)
  {
  lqt_dump("       display_flags:            %08x\n", table->tx3g.display_flags);
  lqt_dump("       horizontal_justification: %d\n", table->tx3g.horizontal_justification);
  lqt_dump("       vertical_justification:   %d\n", table->tx3g.vertical_justification);
  lqt_dump("       back_color:               [%d,%d,%d,%d]\n",
           table->tx3g.back_color[0],
           table->tx3g.back_color[1],
           table->tx3g.back_color[2],
           table->tx3g.back_color[3]);
  lqt_dump("       defaultTextBox:           [%d,%d,%d,%d]\n",
           table->tx3g.defaultTextBox[0],
           table->tx3g.defaultTextBox[1],
           table->tx3g.defaultTextBox[2],
           table->tx3g.defaultTextBox[3]);
  lqt_dump("       start_char_offset:        %d\n", table->tx3g.start_char_offset);
  lqt_dump("       end_char_offset:          %d\n", table->tx3g.end_char_offset);
  lqt_dump("       font_id:                  %d\n", table->tx3g.font_id);
  lqt_dump("       style_flags:              %02x\n", table->tx3g.style_flags);
  lqt_dump("       font_size:                %d\n", table->tx3g.font_size);
  lqt_dump("       text_color:               [%d,%d,%d,%d]\n",
           table->tx3g.text_color[0], table->tx3g.text_color[1],
           table->tx3g.text_color[2], table->tx3g.text_color[3]);

  if(table->tx3g.has_ftab)
    {
    quicktime_ftab_dump(&table->tx3g.ftab);
    }
  }

/* Timecode */

static void
quicktime_stsdtable_read_timecode(quicktime_t *file,
                                  quicktime_stsd_table_t *table,
                                  quicktime_atom_t *parent_atom)
  {
  quicktime_atom_t leaf_atom;
  table->tmcd.reserved2 = quicktime_read_int32(file);
  table->tmcd.flags = quicktime_read_int32(file);
  table->tmcd.timescale = quicktime_read_int32(file);
  table->tmcd.frameduration = quicktime_read_int32(file);
  table->tmcd.numframes = quicktime_read_char(file);
  table->tmcd.reserved3 = quicktime_read_char(file);
  //  table->tmcd.reserved3[1] = quicktime_read_char(file);
  //  table->tmcd.reserved3[2] = quicktime_read_char(file);

  while(quicktime_position(file) < parent_atom->end)
    {
    quicktime_atom_read_header(file, &leaf_atom);
    if(quicktime_atom_is(&leaf_atom, "name"))
      {
      int len = 0;
      quicktime_read_udta_string(file,
                                 &(table->tmcd.name),
                                 &len, 0);
      }
    else
      quicktime_atom_skip(file, &leaf_atom);
    }
  
  quicktime_atom_skip(file, parent_atom);
  }

static void
quicktime_write_stsd_timecode(quicktime_t *file,
                              quicktime_stsd_table_t *table)
  {
  lqt_charset_converter_t * cnv = (lqt_charset_converter_t *)0;
  quicktime_atom_t child_atom;
  quicktime_write_int32(file, table->tmcd.reserved2);
  quicktime_write_int32(file, table->tmcd.flags);
  quicktime_write_int32(file, table->tmcd.timescale);
  quicktime_write_int32(file, table->tmcd.frameduration);
  quicktime_write_char(file, table->tmcd.numframes);
  quicktime_write_char(file, table->tmcd.reserved3);
  
  quicktime_atom_write_header(file, &child_atom, "name");
  quicktime_write_udta_string(file, table->tmcd.name,
                              0, &cnv);
  
  quicktime_atom_write_footer(file, &child_atom);
  if(cnv)
    lqt_charset_converter_destroy(cnv);
  }

static void quicktime_stsdtable_dump_timecode(quicktime_stsd_table_t *table)
  {
  printf("       reserved2       %d\n", table->tmcd.reserved2);
  printf("       flags          %d\n", table->tmcd.flags);
  printf("       timescale      %d\n", table->tmcd.timescale);
  printf("       frameduration  %d\n", table->tmcd.frameduration);
  printf("       numframes      %d\n", table->tmcd.numframes);
  printf("       reserved3      %02x\n",
         table->tmcd.reserved3);
  printf("       name:          %s\n", table->tmcd.name);
  }

/* Audio */

void quicktime_read_stsd_audio(quicktime_t *file, quicktime_stsd_table_t *table,
                               quicktime_atom_t *parent_atom)
  {
  quicktime_atom_t leaf_atom;
  table->version = quicktime_read_int16(file);
  table->revision = quicktime_read_int16(file);
  quicktime_read_data(file, (uint8_t*)(table->vendor), 4);

  if(table->version < 2)
    {
    table->channels = quicktime_read_int16(file);
    table->sample_size = quicktime_read_int16(file);
    table->compression_id = quicktime_read_int16(file);
    table->packet_size = quicktime_read_int16(file);
    table->samplerate = quicktime_read_fixed32(file);
    // Kluge for fixed32 limitation
    if(table->samplerate + 65536 == 96000 ||
       table->samplerate + 65536 == 88200) table->samplerate += 65536;
          
          
    if(table->version == 1)
      {
      table->audio_samples_per_packet = quicktime_read_int32(file);
      table->audio_bytes_per_packet = quicktime_read_int32(file);
      table->audio_bytes_per_frame  = quicktime_read_int32(file);
      table->audio_bytes_per_sample  = quicktime_read_int32(file);
            
      if(table->version == 2) // Skip another 20 bytes
        quicktime_set_position(file, quicktime_position(file) + 20);
            
      }
    }