vcd.c

linux下的MPEG1

      && vcd_mpeg_get_norm (&sequence->info->shdr[0]) != MPEG_NORM_NTSC)
    vcd_warn ("VCD 1.x should contain only NTSC/FILM video (may work with PAL nevertheless)");

  if (!_vcd_obj_has_cap_p (obj, _CAP_MPEG1)
      && sequence->info->version == MPEG_VERS_MPEG1)
    vcd_warn ("this VCD type should not contain MPEG1 streams");

  if (!_vcd_obj_has_cap_p (obj, _CAP_MPEG2)
      && sequence->info->version == MPEG_VERS_MPEG2)
    vcd_warn ("this VCD type should not contain MPEG2 streams");

  if (!sequence->info->shdr[0].seen
      || sequence->info->shdr[1].seen
      || sequence->info->shdr[2].seen)
    vcd_warn ("sequence items should contain a motion video stream!");

  {
    int i;

    for (i = 0; i < 3; i++)
      {
        if (sequence->info->ahdr[i].seen)
          {
            if (i && !_vcd_obj_has_cap_p (obj, _CAP_MPEG2))
              vcd_warn ("audio stream #%d not supported by this VCD type", i);

            if (sequence->info->ahdr[i].sampfreq != 44100)
              vcd_warn ("audio stream #%d has sampling frequency %d Hz (should be 44100 Hz)", 
                        i, sequence->info->ahdr[i].sampfreq);

            if (sequence->info->ahdr[i].layer != 2)
              vcd_warn ("audio stream #%d is not layer II", i);

            if (_vcd_obj_has_cap_p (obj, _CAP_MPEG1) 
                && sequence->info->ahdr[i].bitrate != 224*1024)
              vcd_warn ("audio stream #%d has bitrate %d kbps (should be 224 kbps for this vcd type)",
                        i, sequence->info->ahdr[i].bitrate);
          }
        else if (!i && !_vcd_obj_has_cap_p (obj, _CAP_MPEG2))
          {
            vcd_warn ("this VCD type requires an audio stream to be present");
          }
      }
  }
    
  /* vcd_debug ("track# %d's detected playing time: %.2f seconds",  */
  /*            track_no, sequence->info->playing_time); */

  _cdio_list_append (obj->mpeg_sequence_list, sequence);

  return track_no;
}

static int
_pause_cmp (pause_t *ent1, pause_t *ent2)
{
  if (ent1->time < ent2->time)
    return -1;

  if (ent1->time > ent2->time)
    return 1;

  return 0;
}

int 
vcd_obj_add_sequence_pause (VcdObj *obj, const char sequence_id[], 
                            double pause_time, const char pause_id[])
{
  mpeg_sequence_t *_sequence;

  vcd_assert (obj != NULL);

  if (sequence_id)
    _sequence = _vcd_obj_get_sequence_by_id (obj, sequence_id);
  else
    _sequence = 
      _cdio_list_node_data (_cdio_list_end (obj->mpeg_sequence_list));

  if (!_sequence)
    {
      vcd_error ("sequence id `%s' not found", sequence_id);
      return -1;
    }

  if (pause_id)
    vcd_warn ("pause id ignored...");

  {
    pause_t *_pause = _vcd_malloc (sizeof (pause_t));

    if (pause_id)
      _pause->id = strdup (pause_id);
    _pause->time = pause_time;

    _cdio_list_append (_sequence->pause_list, _pause);
  }

  _vcd_list_sort (_sequence->pause_list, 
                  (_cdio_list_cmp_func) _pause_cmp);

  vcd_debug ("added autopause point at %f", pause_time);

  return 0;
}

int 
vcd_obj_add_segment_pause (VcdObj *obj, const char segment_id[], 
                            double pause_time, const char pause_id[])
{
  mpeg_segment_t *_segment;

  vcd_assert (obj != NULL);

  if (segment_id)
    _segment = _vcd_obj_get_segment_by_id (obj, segment_id);
  else
    _segment = _cdio_list_node_data (_cdio_list_end (obj->mpeg_segment_list));

  if (!_segment)
    {
      vcd_error ("segment id `%s' not found", segment_id);
      return -1;
    }

  if (pause_id)
    vcd_warn ("pause id ignored...");

  {
    pause_t *_pause = _vcd_malloc (sizeof (pause_t));

    if (pause_id)
      _pause->id = strdup (pause_id);
    _pause->time = pause_time;

    _cdio_list_append (_segment->pause_list, _pause);
  }

  _vcd_list_sort (_segment->pause_list, 
                  (_cdio_list_cmp_func) _pause_cmp);

  vcd_debug ("added autopause point at %f", pause_time);

  return 0;
}

static int
_entry_cmp (entry_t *ent1, entry_t *ent2)
{
  if (ent1->time < ent2->time)
    return -1;

  if (ent1->time > ent2->time)
    return 1;

  return 0;
}

int 
vcd_obj_add_sequence_entry (VcdObj *obj, const char sequence_id[], 
                            double entry_time, const char entry_id[])
{
  mpeg_sequence_t *_sequence;

  vcd_assert (obj != NULL);

  if (sequence_id)
    _sequence = _vcd_obj_get_sequence_by_id (obj, sequence_id);
  else
    _sequence =
      _cdio_list_node_data (_cdio_list_end (obj->mpeg_sequence_list));

  if (!_sequence)
    {
      vcd_error ("sequence id `%s' not found", sequence_id);
      return -1;
    }

  if (_cdio_list_length (_sequence->entry_list) >= MAX_SEQ_ENTRIES)
    {
      vcd_error ("only %d entries per sequence allowed!", MAX_SEQ_ENTRIES);
      return -1;
    }

  if (entry_id && _vcd_pbc_lookup (obj, entry_id))
    {
      vcd_error ("item id (%s) exists already", entry_id);
      return -1;
    }

  {
    entry_t *_entry = _vcd_malloc (sizeof (entry_t));

    if (entry_id)
      _entry->id = strdup (entry_id);
    _entry->time = entry_time;

    _cdio_list_append (_sequence->entry_list, _entry);
  }

  _vcd_list_sort (_sequence->entry_list, 
                  (_cdio_list_cmp_func) _entry_cmp);

  return 0;
}

void 
vcd_obj_destroy (VcdObj *obj)
{
  CdioListNode *node;

  vcd_assert (obj != NULL);
  vcd_assert (!obj->in_output);

  free (obj->iso_volume_label);
  free (obj->iso_application_id);

  _CDIO_LIST_FOREACH (node, obj->custom_file_list)
    {
      custom_file_t *p = _cdio_list_node_data (node);
    
      free (p->iso_pathname);
    }

  _cdio_list_free (obj->custom_file_list, true);

  _cdio_list_free (obj->custom_dir_list, true);

  while (_cdio_list_length (obj->mpeg_sequence_list))
    _vcd_obj_remove_mpeg_track (obj, 0);
  _cdio_list_free (obj->mpeg_sequence_list, true);

  free (obj);
}

int 
vcd_obj_set_param_uint (VcdObj *obj, vcd_parm_t param, unsigned arg)
{
  vcd_assert (obj != NULL);

  switch (param) 
    {
    case VCD_PARM_VOLUME_COUNT:
      obj->info_volume_count = arg;
      if (!IN (obj->info_volume_count, 1, 65535))
        {
          obj->info_volume_count = CLAMP (obj->info_volume_count, 1, 65535);
          vcd_warn ("volume count out of range, clamping to range");
        }
      vcd_debug ("changed volume count to %u", obj->info_volume_count);
      break;

    case VCD_PARM_VOLUME_NUMBER:
      obj->info_volume_number = arg;
      if (!IN (obj->info_volume_number, 0, 65534))
        {
          obj->info_volume_number = CLAMP (obj->info_volume_number, 0, 65534);
          vcd_warn ("volume number out of range, clamping to range");
        }
      vcd_debug ("changed volume number to %u", obj->info_volume_number);
      break;

    case VCD_PARM_RESTRICTION:
      obj->info_restriction = arg;
      if (!IN (obj->info_restriction, 0, 3))
        {
          obj->info_restriction = CLAMP (obj->info_restriction, 0, 65534);
          vcd_warn ("restriction out of range, clamping to range");
        }
      vcd_debug ("changed restriction number to %u", obj->info_restriction);
      break;

    case VCD_PARM_LEADOUT_PREGAP:
      obj->leadout_pregap = arg;
      if (!IN (obj->leadout_pregap, 0, 300))
        {
          obj->leadout_pregap = CLAMP (obj->leadout_pregap, 0, 300);
          vcd_warn ("ledout pregap out of range, clamping to allowed range");
        }
      if (obj->leadout_pregap < CDIO_PREGAP_SECTORS)
        vcd_warn ("track leadout pregap set below %d sectors; created (s)vcd may be non-working", 
                  CDIO_PREGAP_SECTORS);

      vcd_debug ("changed leadout pregap to %u", obj->leadout_pregap);
      break;

    case VCD_PARM_TRACK_PREGAP:
      obj->track_pregap = arg;
      if (!IN (obj->track_pregap, 1, 300))
        {
          obj->track_pregap = CLAMP (obj->track_pregap, 1, 300);
          vcd_warn ("track pregap out of range, clamping to allowed range");
        }
      if (obj->track_pregap < CDIO_PREGAP_SECTORS)
        vcd_warn ("track pre gap set below %d sectors; created (S)VCD may be non-working", 
                  CDIO_PREGAP_SECTORS);
      vcd_debug ("changed track pregap to %u", obj->track_pregap);
      break;

    case VCD_PARM_TRACK_FRONT_MARGIN:
      obj->track_front_margin = arg;
      if (!IN (obj->track_front_margin, 0, CDIO_PREGAP_SECTORS))
        {
          obj->track_front_margin = CLAMP (obj->track_front_margin, 0, 
                                           CDIO_PREGAP_SECTORS);
          vcd_warn ("front margin out of range, clamping to allowed range");
        }
      if (_vcd_obj_has_cap_p (obj, _CAP_TRACK_MARGINS) 
          && obj->track_front_margin < 15)
        vcd_warn ("front margin set smaller than recommended (%d < 15 sectors) for disc type used",
                  obj->track_front_margin);

      vcd_debug ("changed front margin to %u", obj->track_front_margin);
      break;

    case VCD_PARM_TRACK_REAR_MARGIN:
      obj->track_rear_margin = arg;
      if (!IN (obj->track_rear_margin, 0, CDIO_POSTGAP_SECTORS))
        {
          obj->track_rear_margin = CLAMP (obj->track_rear_margin, 0, 
                                          CDIO_POSTGAP_SECTORS);
          vcd_warn ("rear margin out of range, clamping to allowed range");
        }
      if (_vcd_obj_has_cap_p (obj, _CAP_TRACK_MARGINS) 
          && obj->track_rear_margin < 15)
        vcd_warn ("rear margin set smaller than recommended (%d < 15 sectors) for disc type used",
                  obj->track_rear_margin);
      vcd_debug ("changed rear margin to %u", obj->track_rear_margin);
      break;

    default:
      vcd_assert_not_reached ();
      break;
    }

  return 0;
}

int 
vcd_obj_set_param_str (VcdObj *obj, vcd_parm_t param, const char *arg)
{
  vcd_assert (obj != NULL);
  vcd_assert (arg != NULL);

  switch (param) 
    {
    case VCD_PARM_VOLUME_ID:
      free (obj->iso_volume_label);
      obj->iso_volume_label = strdup (arg);
      if (strlen (obj->iso_volume_label) > 32)
        {
          obj->iso_volume_label[32] = '\0';
          vcd_warn ("Volume label too long, will be truncated");
        }
      vcd_debug ("changed volume label to `%s'", obj->iso_volume_label);
      break;

    case VCD_PARM_PUBLISHER_ID:
      free (obj->iso_publisher_id);
      obj->iso_publisher_id = strdup (arg);
      if (strlen (obj->iso_publisher_id) > 128)
        {
          obj->iso_publisher_id[128] = '\0';
          vcd_warn ("Publisher ID too long, will be truncated");
        }
      vcd_debug ("changed publisher id to `%s'", obj->iso_publisher_id);
      break;

    case VCD_PARM_PREPARER_ID:
      free (obj->iso_preparer_id);
      obj->iso_preparer_id = strdup (arg);
      if (strlen (obj->iso_preparer_id) > 128)
        {
          obj->iso_preparer_id[128] = '\0';
          vcd_warn ("Preparer ID too long, will be truncated");
        }
      vcd_debug ("changed preparer id to `%s'", obj->iso_preparer_id);
      break;

    case VCD_PARM_APPLICATION_ID:
      free (obj->iso_application_id);
      obj->iso_application_id = strdup (arg);
      if (strlen (obj->iso_application_id) > 128)
        {
          obj->iso_application_id[128] = '\0';
          vcd_warn ("Application ID too long, will be truncated");
        }
      vcd_debug ("changed application id to `%s'", obj->iso_application_id);
      break;
      
    case VCD_PARM_ALBUM_ID:
      free (obj->info_album_id);
      obj->info_album_id = strdup (arg);
      if (strlen (obj->info_album_id) > 16)
        {
          obj->info_album_id[16] = '\0';
          vcd_warn ("Album ID too long, will be truncated");
        }
      vcd_debug ("changed album id to `%s'", obj->info_album_id);
      break;

    default:
      vcd_assert_not_reached ();
      break;
    }

  return 0;
}

int 
vcd_obj_set_param_bool (VcdObj *obj, vcd_parm_t param, bool arg)
{
  vcd_assert (obj != NULL);

  switch (param) 
    {
    case VCD_PARM_RELAXED_APS:
      obj->relaxed_aps = arg ? true : false;
      vcd_debug ("changing 'relaxed aps' to %d", obj->relaxed_aps);
      break;

    case VCD_PARM_NEXT_VOL_LID2:
      obj->info_use_lid2 = arg ? true : false;
      vcd_debug ("changing 'next volume use lid 2' to %d", obj->info_use_lid2);
      break;

    case VCD_PARM_NEXT_VOL_SEQ2:
      obj->info_use_seq2 = arg ? true : false;
      vcd_debug ("changing 'next volume use sequence 2' to %d", obj->info_use_seq2);
      break;

    case VCD_PARM_SVCD_VCD3_MPEGAV:
      if (obj->type == VCD_TYPE_SVCD)
        {
          if ((obj->svcd_vcd3_mpegav = arg ? true : false))
            vcd_warn ("!! enabling deprecated VCD3.0 MPEGAV folder --" 
                      " SVCD will not be IEC62107 compliant !!");
        }
      else
        vcd_error ("parameter not applicable for vcd type");
      break;

    case VCD_PARM_SVCD_VCD3_ENTRYSVD:
      if (obj->type == VCD_TYPE_SVCD)
        {
          if ((obj->svcd_vcd3_entrysvd = arg ? true : false))
            vcd_warn ("!! enabling deprecated VCD3.0 ENTRYSVD signature --" 
                      " SVCD will not be IEC62107 compliant !!");
        }
      else
        vcd_error ("parameter not applicable for vcd type");
      break;

    case VCD_PARM_SVCD_VCD3_TRACKSVD:
      if (obj->type == VCD_TYPE_SVCD)
        {
          if ((obj->svcd_vcd3_tracksvd = arg ? true : false))
            vcd_warn ("!! enabling deprecated VCD3.0 TRACK.SVD format --" 
                      " SVCD will not be IEC62107 compliant !!");
        }
      else
        vcd_error ("parameter not applicable for vcd type");
      break;

    case VCD_PARM_UPDATE_SCAN_OFFSETS:
      if (_vcd_obj_has_cap_p (obj, _CAP_4C_SVCD))
        {
          obj->update_scan_offsets = arg ? true : false;
          vcd_debug ("changing 'update scan offsets' to %d", obj->update_scan_offsets);
        }
      else
        vcd_error ("parameter not applicable for vcd type");
      break;

    case VCD_PARM_LEADOUT_PAUSE:
      vcd_warn ("use of 'leadout pause' is deprecated and may be removed in later releases;"
                " use 'leadout pregap' instead");
      vcd_obj_set_param_uint (obj, VCD_PARM_LEADOUT_PREGAP, 
                              (arg ? CDIO_PREGAP_SECTORS : 0));
      break;