/* $Id: vcd.c,v 1.1 2003/10/13 11:47:12 f1rmb Exp $ Copyright (C) 2000 Herbert Valerio Riedel This program 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. This program 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 this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include #include #include #include #include #include /* public headers */ #include #include #include #include #include /* Private headers */ #include "assert.h" #include "dict.h" #include "directory.h" #include "obj.h" #include "pbc.h" #include "salloc.h" #include "util.h" #include "vcd.h" static const char _rcsid[] = "$Id: vcd.c,v 1.1 2003/10/13 11:47:12 f1rmb Exp $"; static const char zero[CDIO_CD_FRAMESIZE_RAW] = { 0, }; #define DEFAULT_ISO_PREPARER_ID "GNU VCDImager " VERSION " " HOST_ARCH /* exported private functions */ mpeg_sequence_t * _vcd_obj_get_sequence_by_id (VcdObj *obj, const char sequence_id[]) { VcdListNode *node; vcd_assert (sequence_id != NULL); vcd_assert (obj != NULL); _VCD_LIST_FOREACH (node, obj->mpeg_sequence_list) { mpeg_sequence_t *_sequence = _vcd_list_node_data (node); if (_sequence->id && !strcmp (sequence_id, _sequence->id)) return _sequence; } return NULL; } mpeg_sequence_t * _vcd_obj_get_sequence_by_entry_id (VcdObj *obj, const char entry_id[]) { VcdListNode *node; vcd_assert (entry_id != NULL); vcd_assert (obj != NULL); _VCD_LIST_FOREACH (node, obj->mpeg_sequence_list) { mpeg_sequence_t *_sequence = _vcd_list_node_data (node); VcdListNode *node2; /* default entry point */ if (_sequence->default_entry_id && !strcmp (entry_id, _sequence->default_entry_id)) return _sequence; /* additional entry points */ _VCD_LIST_FOREACH (node2, _sequence->entry_list) { entry_t *_entry = _vcd_list_node_data (node2); if (_entry->id && !strcmp (entry_id, _entry->id)) return _sequence; } } /* not found */ return NULL; } mpeg_segment_t * _vcd_obj_get_segment_by_id (VcdObj *obj, const char segment_id[]) { VcdListNode *node; vcd_assert (segment_id != NULL); vcd_assert (obj != NULL); _VCD_LIST_FOREACH (node, obj->mpeg_segment_list) { mpeg_segment_t *_segment = _vcd_list_node_data (node); if (_segment->id && !strcmp (segment_id, _segment->id)) return _segment; } return NULL; } bool _vcd_obj_has_cap_p (const VcdObj *obj, enum vcd_capability_t capability) { switch (capability) { case _CAP_VALID: switch (obj->type) { case VCD_TYPE_VCD: case VCD_TYPE_VCD11: case VCD_TYPE_VCD2: case VCD_TYPE_SVCD: case VCD_TYPE_HQVCD: return true; break; case VCD_TYPE_INVALID: return false; break; } break; case _CAP_MPEG2: switch (obj->type) { case VCD_TYPE_VCD: case VCD_TYPE_VCD11: case VCD_TYPE_VCD2: case VCD_TYPE_INVALID: return false; break; case VCD_TYPE_SVCD: case VCD_TYPE_HQVCD: return true; break; } break; case _CAP_PBC: switch (obj->type) { case VCD_TYPE_VCD: case VCD_TYPE_VCD11: case VCD_TYPE_INVALID: return false; break; case VCD_TYPE_VCD2: case VCD_TYPE_SVCD: case VCD_TYPE_HQVCD: return true; break; } break; case _CAP_PBC_X: switch (obj->type) { case VCD_TYPE_VCD: case VCD_TYPE_VCD11: case VCD_TYPE_INVALID: case VCD_TYPE_SVCD: case VCD_TYPE_HQVCD: return false; break; case VCD_TYPE_VCD2: return true; break; } break; case _CAP_4C_SVCD: switch (obj->type) { case VCD_TYPE_VCD: case VCD_TYPE_VCD11: case VCD_TYPE_INVALID: case VCD_TYPE_VCD2: return false; break; case VCD_TYPE_SVCD: case VCD_TYPE_HQVCD: return true; break; } break; case _CAP_PAL_BITS: return _vcd_obj_has_cap_p (obj, _CAP_PBC); /* for now */ break; case _CAP_MPEG1: return !_vcd_obj_has_cap_p (obj, _CAP_MPEG2); /* for now */ break; case _CAP_TRACK_MARGINS: return !_vcd_obj_has_cap_p (obj, _CAP_MPEG2); /* for now */ break; } vcd_assert_not_reached (); return false; } /* * public methods */ VcdObj * vcd_obj_new (vcd_type_t vcd_type) { VcdObj *new_obj = NULL; static bool _first = true; if (_first) { #if defined(_DEVELOPMENT_) vcd_warn ("initializing libvcd %s [%s]", VERSION, HOST_ARCH); vcd_warn (" "); vcd_warn (" this is the UNSTABLE development branch!"); vcd_warn (" use only if you know what you are doing"); vcd_warn (" see http://www.hvrlab.org/~hvr/vcdimager/ for more information"); vcd_warn (" "); #else vcd_debug ("initializing libvcd %s [%s]", VERSION, HOST_ARCH); #endif _first = false; } new_obj = _vcd_malloc (sizeof (VcdObj)); new_obj->type = vcd_type; if (!_vcd_obj_has_cap_p (new_obj, _CAP_VALID)) { vcd_error ("VCD type not supported"); free (new_obj); return NULL; } if (vcd_type == VCD_TYPE_VCD) vcd_warn ("VCD 1.0 support is experimental -- user feedback needed!"); new_obj->iso_volume_label = strdup (""); new_obj->iso_publisher_id = strdup (""); new_obj->iso_application_id = strdup (""); new_obj->iso_preparer_id = _vcd_strdup_upper (DEFAULT_ISO_PREPARER_ID); new_obj->info_album_id = strdup (""); new_obj->info_volume_count = 1; new_obj->info_volume_number = 1; new_obj->custom_file_list = _vcd_list_new (); new_obj->custom_dir_list = _vcd_list_new (); new_obj->mpeg_sequence_list = _vcd_list_new (); new_obj->mpeg_segment_list = _vcd_list_new (); new_obj->pbc_list = _vcd_list_new (); /* gap's defined by IEC-10149 / ECMA-130 */ /* pre-gap's for tracks but the first one */ new_obj->track_pregap = CDIO_PREGAP_SECTORS; /* post-gap after last track */ new_obj->leadout_pregap = CDIO_POSTGAP_SECTORS; if (_vcd_obj_has_cap_p (new_obj, _CAP_TRACK_MARGINS)) { new_obj->track_front_margin = 30; new_obj->track_rear_margin = 45; } else { new_obj->track_front_margin = 0; new_obj->track_rear_margin = 0; } return new_obj; } int vcd_obj_remove_item (VcdObj *obj, const char id[]) { vcd_warn ("vcd_obj_remove_item('%s') not implemented yet!", id); return -1; } static void _vcd_obj_remove_mpeg_track (VcdObj *obj, int track_id) { int length; mpeg_sequence_t *track = NULL; VcdListNode *node = NULL; vcd_assert (track_id >= 0); node = _vcd_list_at (obj->mpeg_sequence_list, track_id); vcd_assert (node != NULL); track = (mpeg_sequence_t *) _vcd_list_node_data (node); vcd_mpeg_source_destroy (track->source, true); length = track->info->packets; length += obj->track_pregap + obj->track_front_margin + 0 + obj->track_rear_margin; /* fixup offsets */ { VcdListNode *node2 = node; while ((node2 = _vcd_list_node_next (node2)) != NULL) ((mpeg_sequence_t *) _vcd_list_node_data (node))->relative_start_extent -= length; } obj->relative_end_extent -= length; /* shift up */ _vcd_list_node_free (node, true); } int vcd_obj_append_segment_play_item (VcdObj *obj, VcdMpegSource *mpeg_source, const char item_id[]) { mpeg_segment_t *segment = NULL; vcd_assert (obj != NULL); vcd_assert (mpeg_source != NULL); if (!_vcd_obj_has_cap_p (obj, _CAP_PBC)) { vcd_error ("segment play items not supported for this vcd type"); return -1; } if (!item_id) { vcd_error ("no id given for segment play item"); return -1; } if (_vcd_pbc_lookup (obj, item_id)) { vcd_error ("item id (%s) exists already", item_id); return -1; } vcd_info ("scanning mpeg segment item #%d for scanpoints...", _vcd_list_length (obj->mpeg_segment_list)); vcd_mpeg_source_scan (mpeg_source, !obj->relaxed_aps, obj->update_scan_offsets, NULL, NULL); if (vcd_mpeg_source_get_info (mpeg_source)->packets == 0) { vcd_error ("mpeg is empty?"); return -1; } /* create list node */ segment = _vcd_malloc (sizeof (mpeg_sequence_t)); segment->source = mpeg_source; segment->id = strdup (item_id); segment->info = vcd_mpeg_source_get_info (mpeg_source); segment->segment_count = _vcd_len2blocks (segment->info->packets, 150); segment->pause_list = _vcd_list_new (); vcd_debug ("SPI length is %d sector(s), allocated %d segment(s)", segment->info->packets, segment->segment_count); _vcd_list_append (obj->mpeg_segment_list, segment); return 0; } int vcd_obj_append_sequence_play_item (VcdObj *obj, VcdMpegSource *mpeg_source, const char item_id[], const char default_entry_id[]) { unsigned length; mpeg_sequence_t *sequence = NULL; int track_no = _vcd_list_length (obj->mpeg_sequence_list); vcd_assert (obj != NULL); vcd_assert (mpeg_source != NULL); if (item_id && _vcd_pbc_lookup (obj, item_id)) { vcd_error ("item id (%s) exist already", item_id); return -1; } if (default_entry_id && _vcd_pbc_lookup (obj, default_entry_id)) { vcd_error ("default entry id (%s) exist already", default_entry_id); return -1; } if (default_entry_id && item_id && !strcmp (item_id, default_entry_id)) { vcd_error ("default entry id == item id (%s)", item_id); return -1; } vcd_info ("scanning mpeg sequence item #%d for scanpoints...", track_no); vcd_mpeg_source_scan (mpeg_source, !obj->relaxed_aps, obj->update_scan_offsets, NULL, NULL); sequence = _vcd_malloc (sizeof (mpeg_sequence_t)); sequence->source = mpeg_source; if (item_id) sequence->id = strdup (item_id); if (default_entry_id) sequence->default_entry_id = strdup (default_entry_id); sequence->info = vcd_mpeg_source_get_info (mpeg_source); length = sequence->info->packets; sequence->entry_list = _vcd_list_new (); sequence->pause_list = _vcd_list_new (); obj->relative_end_extent += obj->track_pregap; sequence->relative_start_extent = obj->relative_end_extent; obj->relative_end_extent += obj->track_front_margin + length + obj->track_rear_margin; /* sanity checks */ if (length < 75) vcd_warn ("mpeg stream shorter than 75 sectors"); if (!_vcd_obj_has_cap_p (obj, _CAP_PAL_BITS) && vcd_mpeg_get_norm (&sequence->info->shdr[0]) != MPEG_NORM_FILM && 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); */ _vcd_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 = _vcd_list_node_data (_vcd_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; _vcd_list_append (_sequence->pause_list, _pause); } _vcd_list_sort (_sequence->pause_list, (_vcd_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 = _vcd_list_node_data (_vcd_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; _vcd_list_append (_segment->pause_list, _pause); } _vcd_list_sort (_segment->pause_list, (_vcd_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 = _vcd_list_node_data (_vcd_list_end (obj->mpeg_sequence_list)); if (!_sequence) { vcd_error ("sequence id `%s' not found", sequence_id); return -1; } if (_vcd_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; _vcd_list_append (_sequence->entry_list, _entry); } _vcd_list_sort (_sequence->entry_list, (_vcd_list_cmp_func) _entry_cmp); return 0; } void vcd_obj_destroy (VcdObj *obj) { VcdListNode *node; vcd_assert (obj != NULL); vcd_assert (!obj->in_output); free (obj->iso_volume_label); free (obj->iso_application_id); _VCD_LIST_FOREACH (node, obj->custom_file_list) { custom_file_t *p = _vcd_list_node_data (node); free (p->iso_pathname); } _vcd_list_free (obj->custom_file_list, true); _vcd_list_free (obj->custom_dir_list, true); while (_vcd_list_length (obj->mpeg_sequence_list)) _vcd_obj_remove_mpeg_track (obj, 0); _vcd_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; default: vcd_assert_not_reached (); break; } return 0; } int vcd_obj_add_dir (VcdObj *obj, const char iso_pathname[]) { char *_iso_pathname; vcd_assert (obj != NULL); vcd_assert (iso_pathname != NULL); _iso_pathname = _vcd_strdup_upper (iso_pathname); if (!iso9660_dirname_valid_p (_iso_pathname)) { vcd_error("pathname `%s' is not a valid iso pathname", _iso_pathname); free (_iso_pathname); return 1; } _vcd_list_append (obj->custom_dir_list, _iso_pathname); _vcd_list_sort (obj->custom_dir_list, (_vcd_list_cmp_func) strcmp); return 0; } int vcd_obj_add_file (VcdObj *obj, const char iso_pathname[], VcdDataSource *file, bool raw_flag) { uint32_t size = 0, sectors = 0; vcd_assert (obj != NULL); vcd_assert (file != NULL); vcd_assert (iso_pathname != NULL); vcd_assert (strlen (iso_pathname) > 0); vcd_assert (file != NULL); size = vcd_data_source_stat (file); /* close file to save file descriptors */ vcd_data_source_close (file); if (raw_flag) { if (!size) { vcd_error("raw mode2 file must not be empty\n"); return 1; } sectors = size / M2RAW_SECTOR_SIZE; if (size % M2RAW_SECTOR_SIZE) { vcd_error("raw mode2 file must have size multiple of %d \n", M2RAW_SECTOR_SIZE); return 1; } } else sectors = _vcd_len2blocks (size, CDIO_CD_FRAMESIZE); { custom_file_t *p; char *_iso_pathname = _vcd_strdup_upper (iso_pathname); if (!iso9660_pathname_valid_p (_iso_pathname)) { vcd_error("pathname `%s' is not a valid iso pathname", _iso_pathname); free (_iso_pathname); return 1; } p = _vcd_malloc (sizeof (custom_file_t)); p->file = file; p->iso_pathname = _iso_pathname; p->raw_flag = raw_flag; p->size = size; p->start_extent = 0; p->sectors = sectors; _vcd_list_append (obj->custom_file_list, p); } return 0; } static void _finalize_vcd_iso_track_allocation (VcdObj *obj) { int n; VcdListNode *node; uint32_t dir_secs = SECTOR_NIL; _dict_clean (obj); /* pre-alloc 16 blocks of ISO9660 required silence */ if (_vcd_salloc (obj->iso_bitmap, 0, 16) == SECTOR_NIL) vcd_assert_not_reached (); /* keep karaoke sectors blank -- well... guess I'm too paranoid :) */ if (_vcd_salloc (obj->iso_bitmap, 75, 75) == SECTOR_NIL) vcd_assert_not_reached (); /* pre-alloc descriptors, PVD */ _dict_insert (obj, "pvd", ISO_PVD_SECTOR, 1, SM_EOR); /* EOR */ /* EVD */ _dict_insert (obj, "evd", ISO_EVD_SECTOR, 1, SM_EOR|SM_EOF); /* EOR+EOF */ /* reserve for iso directory */ dir_secs = _vcd_salloc (obj->iso_bitmap, 18, 75-18); /* VCD information area */ _dict_insert (obj, "info", INFO_VCD_SECTOR, 1, SM_EOF); /* INFO.VCD */ /* EOF */ _dict_insert (obj, "entries", ENTRIES_VCD_SECTOR, 1, SM_EOF); /* ENTRIES.VCD */ /* EOF */ /* PBC */ if (_vcd_pbc_available (obj)) { _dict_insert (obj, "lot", LOT_VCD_SECTOR, LOT_VCD_SIZE, SM_EOF); /* LOT.VCD */ /* EOF */ _dict_insert (obj, "psd", PSD_VCD_SECTOR, _vcd_len2blocks (get_psd_size (obj, false), ISO_BLOCKSIZE), SM_EOF); /* PSD.VCD */ /* EOF */ } if (_vcd_obj_has_cap_p (obj, _CAP_4C_SVCD)) { _dict_insert (obj, "tracks", SECTOR_NIL, 1, SM_EOF); /* TRACKS.SVD */ _dict_insert (obj, "search", SECTOR_NIL, _vcd_len2blocks (get_search_dat_size (obj), ISO_BLOCKSIZE), SM_EOF); /* SEARCH.DAT */ vcd_assert (_dict_get_bykey (obj, "tracks")->sector > INFO_VCD_SECTOR); vcd_assert (_dict_get_bykey (obj, "search")->sector > INFO_VCD_SECTOR); } /* done with primary information area */ obj->mpeg_segment_start_extent = _vcd_len2blocks (_vcd_salloc_get_highest (obj->iso_bitmap) + 1, 75) * 75; /* salloc up to end of vcd sector */ for(n = 0;n < obj->mpeg_segment_start_extent;n++) _vcd_salloc (obj->iso_bitmap, n, 1); vcd_assert (_vcd_salloc_get_highest (obj->iso_bitmap) + 1 == obj->mpeg_segment_start_extent); /* insert segments */ _VCD_LIST_FOREACH (node, obj->mpeg_segment_list) { mpeg_segment_t *_segment = _vcd_list_node_data (node); _segment->start_extent = _vcd_salloc (obj->iso_bitmap, SECTOR_NIL, _segment->segment_count * VCDINFO_SEGMENT_SECTOR_SIZE); vcd_assert (_segment->start_extent % 75 == 0); vcd_assert (_vcd_salloc_get_highest (obj->iso_bitmap) + 1 == _segment->start_extent + _segment->segment_count * VCDINFO_SEGMENT_SECTOR_SIZE); } obj->ext_file_start_extent = _vcd_salloc_get_highest (obj->iso_bitmap) + 1; vcd_assert (obj->ext_file_start_extent % 75 == 0); /* go on with EXT area */ if (_vcd_obj_has_cap_p (obj, _CAP_4C_SVCD)) { _dict_insert (obj, "scandata", SECTOR_NIL, _vcd_len2blocks (get_scandata_dat_size (obj), ISO_BLOCKSIZE), SM_EOF); } if (_vcd_obj_has_cap_p (obj, _CAP_PBC_X) &&_vcd_pbc_available (obj)) { _dict_insert (obj, "lot_x", SECTOR_NIL, LOT_VCD_SIZE, SM_EOF); _dict_insert (obj, "psd_x", SECTOR_NIL, _vcd_len2blocks (get_psd_size (obj, true), ISO_BLOCKSIZE), SM_EOF); } obj->custom_file_start_extent = _vcd_salloc_get_highest (obj->iso_bitmap) + 1; /* now for the custom files */ _VCD_LIST_FOREACH (node, obj->custom_file_list) { custom_file_t *p = _vcd_list_node_data (node); if (p->sectors) { p->start_extent = _vcd_salloc(obj->iso_bitmap, SECTOR_NIL, p->sectors); vcd_assert (p->start_extent != SECTOR_NIL); } else /* zero sized files -- set dummy extent */ p->start_extent = obj->custom_file_start_extent; } /* calculate iso size -- after this point no sector shall be allocated anymore */ obj->iso_size = MAX (MIN_ISO_SIZE, _vcd_salloc_get_highest (obj->iso_bitmap) + 1); vcd_debug ("iso9660: highest alloced sector is %lu (using %d as isosize)", (unsigned long int) _vcd_salloc_get_highest (obj->iso_bitmap), obj->iso_size); /* after this point the ISO9660's size is frozen */ } static void _finalize_vcd_iso_track_filesystem (VcdObj *obj) { int n; VcdListNode *node; /* create filesystem entries */ switch (obj->type) { case VCD_TYPE_VCD: case VCD_TYPE_VCD11: case VCD_TYPE_VCD2: /* add only necessary directories! */ /* _vcd_directory_mkdir (obj->dir, "CDDA"); */ /* _vcd_directory_mkdir (obj->dir, "CDI"); */ _vcd_directory_mkdir (obj->dir, "EXT"); /* _vcd_directory_mkdir (obj->dir, "KARAOKE"); */ _vcd_directory_mkdir (obj->dir, "MPEGAV"); _vcd_directory_mkdir (obj->dir, "VCD"); /* add segment dir only when there are actually segment play items */ if (_vcd_list_length (obj->mpeg_segment_list)) _vcd_directory_mkdir (obj->dir, "SEGMENT"); _vcd_directory_mkfile (obj->dir, "VCD/ENTRIES.VCD", _dict_get_bykey (obj, "entries")->sector, ISO_BLOCKSIZE, false, 0); _vcd_directory_mkfile (obj->dir, "VCD/INFO.VCD", _dict_get_bykey (obj, "info")->sector, ISO_BLOCKSIZE, false, 0); /* only for vcd2.0 */ if (_vcd_pbc_available (obj)) { _vcd_directory_mkfile (obj->dir, "VCD/LOT.VCD", _dict_get_bykey (obj, "lot")->sector, ISO_BLOCKSIZE*LOT_VCD_SIZE, false, 0); _vcd_directory_mkfile (obj->dir, "VCD/PSD.VCD", _dict_get_bykey (obj, "psd")->sector, get_psd_size (obj, false), false, 0); } break; case VCD_TYPE_SVCD: case VCD_TYPE_HQVCD: _vcd_directory_mkdir (obj->dir, "EXT"); if (!obj->svcd_vcd3_mpegav) _vcd_directory_mkdir (obj->dir, "MPEG2"); else { vcd_warn ("adding MPEGAV dir for *DEPRECATED* SVCD VCD30 mode"); _vcd_directory_mkdir (obj->dir, "MPEGAV"); } /* add segment dir only when there are actually segment play items */ if (_vcd_list_length (obj->mpeg_segment_list)) _vcd_directory_mkdir (obj->dir, "SEGMENT"); _vcd_directory_mkdir (obj->dir, "SVCD"); _vcd_directory_mkfile (obj->dir, "SVCD/ENTRIES.SVD", _dict_get_bykey (obj, "entries")->sector, ISO_BLOCKSIZE, false, 0); _vcd_directory_mkfile (obj->dir, "SVCD/INFO.SVD", _dict_get_bykey (obj, "info")->sector, ISO_BLOCKSIZE, false, 0); if (_vcd_pbc_available (obj)) { _vcd_directory_mkfile (obj->dir, "SVCD/LOT.SVD", _dict_get_bykey (obj, "lot")->sector, ISO_BLOCKSIZE*LOT_VCD_SIZE, false, 0); _vcd_directory_mkfile (obj->dir, "SVCD/PSD.SVD", _dict_get_bykey (obj, "psd")->sector, get_psd_size (obj, false), false, 0); } _vcd_directory_mkfile (obj->dir, "SVCD/SEARCH.DAT", _dict_get_bykey (obj, "search")->sector, get_search_dat_size (obj), false, 0); _vcd_directory_mkfile (obj->dir, "SVCD/TRACKS.SVD", _dict_get_bykey (obj, "tracks")->sector, ISO_BLOCKSIZE, false, 0); break; default: vcd_assert_not_reached (); break; } /* SEGMENTS */ n = 1; _VCD_LIST_FOREACH (node, obj->mpeg_segment_list) { mpeg_segment_t *segment = _vcd_list_node_data (node); char segment_pathname[128] = { 0, }; const char *fmt = NULL; uint8_t fnum = 0; switch (obj->type) { case VCD_TYPE_VCD2: fmt = "SEGMENT/ITEM%4.4d.DAT"; fnum = 1; break; case VCD_TYPE_SVCD: case VCD_TYPE_HQVCD: fmt = "SEGMENT/ITEM%4.4d.MPG"; fnum = 0; break; default: vcd_assert_not_reached (); } snprintf (segment_pathname, sizeof (segment_pathname), fmt, n); _vcd_directory_mkfile (obj->dir, segment_pathname, segment->start_extent, segment->info->packets * ISO_BLOCKSIZE, true, fnum); vcd_assert (n <= MAX_SEGMENTS); n += segment->segment_count; } /* EXT files */ if (_vcd_obj_has_cap_p (obj, _CAP_PBC_X) &&_vcd_pbc_available (obj)) { /* psd_x -- extended PSD */ _vcd_directory_mkfile (obj->dir, "EXT/PSD_X.VCD", _dict_get_bykey (obj, "psd_x")->sector, get_psd_size (obj, true), false, 1); /* lot_x -- extended LOT */ _vcd_directory_mkfile (obj->dir, "EXT/LOT_X.VCD", _dict_get_bykey (obj, "lot_x")->sector, ISO_BLOCKSIZE*LOT_VCD_SIZE, false, 1); vcd_assert (obj->type == VCD_TYPE_VCD2); } if (_vcd_obj_has_cap_p (obj, _CAP_4C_SVCD)) { /* scandata.dat -- scanpoints */ _vcd_directory_mkfile (obj->dir, "EXT/SCANDATA.DAT", _dict_get_bykey (obj, "scandata")->sector, get_scandata_dat_size (obj), false, 0); } /* custom files/dirs */ _VCD_LIST_FOREACH (node, obj->custom_dir_list) { char *p = _vcd_list_node_data (node); _vcd_directory_mkdir (obj->dir, p); } _VCD_LIST_FOREACH (node, obj->custom_file_list) { custom_file_t *p = _vcd_list_node_data (node); _vcd_directory_mkfile (obj->dir, p->iso_pathname, p->start_extent, (p->raw_flag ? (ISO_BLOCKSIZE * (p->size / M2RAW_SECTOR_SIZE)) : p->size), p->raw_flag, 1); } n = 0; _VCD_LIST_FOREACH (node, obj->mpeg_sequence_list) { char avseq_pathname[128] = { 0, }; const char *fmt = NULL; mpeg_sequence_t *_sequence = _vcd_list_node_data (node); uint32_t extent = _sequence->relative_start_extent; uint8_t file_num = 0; extent += obj->iso_size; switch (obj->type) { case VCD_TYPE_VCD: fmt = "MPEGAV/MUSIC%2.2d.DAT"; file_num = n + 1; break; case VCD_TYPE_VCD11: case VCD_TYPE_VCD2: fmt = "MPEGAV/AVSEQ%2.2d.DAT"; file_num = n + 1; break; case VCD_TYPE_SVCD: case VCD_TYPE_HQVCD: fmt = "MPEG2/AVSEQ%2.2d.MPG"; file_num = 0; /* if vcd3 compat mode, override */ if (obj->svcd_vcd3_mpegav) { fmt = "MPEGAV/AVSEQ%2.2d.MPG"; file_num = n + 1; } break; default: vcd_assert_not_reached (); } vcd_assert (n < 98); snprintf (avseq_pathname, sizeof (avseq_pathname), fmt, n + 1); /* file entry contains front margin, mpeg stream and rear margin */ _vcd_directory_mkfile (obj->dir, avseq_pathname, extent, (obj->track_front_margin + _sequence->info->packets + obj->track_rear_margin) * ISO_BLOCKSIZE, true, file_num); n++; } /* register isofs dir structures */ { uint32_t dirs_size = _vcd_directory_get_size (obj->dir); /* be sure to stay out of information areas */ switch (obj->type) { case VCD_TYPE_VCD: case VCD_TYPE_VCD11: case VCD_TYPE_VCD2: /* karaoke area starts at 03:00 */ if (16 + 2 + dirs_size + 2 >= 75) vcd_error ("directory section to big for a VCD"); break; case VCD_TYPE_SVCD: case VCD_TYPE_HQVCD: /* since no karaoke exists the next fixed area starts at 04:00 */ if (16 + 2 + dirs_size + 2 >= 150) vcd_error ("directory section to big for a SVCD"); break; default: vcd_assert_not_reached (); } /* un-alloc small area */ _vcd_salloc_free (obj->iso_bitmap, 18, dirs_size + 2); /* alloc it again! */ _dict_insert (obj, "dir", 18, dirs_size, SM_EOR|SM_EOF); _dict_insert (obj, "ptl", 18 + dirs_size, 1, SM_EOR|SM_EOF); _dict_insert (obj, "ptm", 18 + dirs_size + 1, 1, SM_EOR|SM_EOF); } } static void _finalize_vcd_iso_track (VcdObj *obj) { _vcd_pbc_finalize (obj); _finalize_vcd_iso_track_allocation (obj); _finalize_vcd_iso_track_filesystem (obj); } static int _callback_wrapper (VcdObj *obj, int force) { const int cb_frequency = 75; if (obj->last_cb_call + cb_frequency > obj->sectors_written && !force) return 0; obj->last_cb_call = obj->sectors_written; if (obj->progress_callback) { progress_info_t _pi; _pi.sectors_written = obj->sectors_written; _pi.total_sectors = obj->relative_end_extent + obj->iso_size; _pi.in_track = obj->in_track; _pi.total_tracks = _vcd_list_length (obj->mpeg_sequence_list) + 1; return obj->progress_callback (&_pi, obj->callback_user_data); } else return 0; } static int _write_m2_image_sector (VcdObj *obj, const void *data, uint32_t extent, uint8_t fnum, uint8_t cnum, uint8_t sm, uint8_t ci) { char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, }; vcd_assert (extent == obj->sectors_written); _vcd_make_mode2(buf, data, extent, fnum, cnum, sm, ci); vcd_image_sink_write (obj->image_sink, buf, extent); obj->sectors_written++; return _callback_wrapper (obj, false); } static int _write_m2_raw_image_sector (VcdObj *obj, const void *data, uint32_t extent) { char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, }; vcd_assert (extent == obj->sectors_written); _vcd_make_raw_mode2(buf, data, extent); vcd_image_sink_write (obj->image_sink, buf, extent); obj->sectors_written++; return _callback_wrapper (obj, false); } static void _write_source_mode2_raw (VcdObj *obj, VcdDataSource *source, uint32_t extent) { int n; uint32_t sectors; sectors = vcd_data_source_stat (source) / M2RAW_SECTOR_SIZE; vcd_data_source_seek (source, 0); for (n = 0;n < sectors;n++) { char buf[M2RAW_SECTOR_SIZE] = { 0, }; vcd_data_source_read (source, buf, M2RAW_SECTOR_SIZE, 1); if (_write_m2_raw_image_sector (obj, buf, extent+n)) break; } vcd_data_source_close (source); } static void _write_source_mode2_form1 (VcdObj *obj, VcdDataSource *source, uint32_t extent) { int n; uint32_t sectors, size, last_block_size; size = vcd_data_source_stat (source); sectors = _vcd_len2blocks (size, CDIO_CD_FRAMESIZE); last_block_size = size % CDIO_CD_FRAMESIZE; if (!last_block_size) last_block_size = CDIO_CD_FRAMESIZE; vcd_data_source_seek (source, 0); for (n = 0;n < sectors;n++) { char buf[CDIO_CD_FRAMESIZE] = { 0, }; vcd_data_source_read (source, buf, ((n + 1 == sectors) ? last_block_size : CDIO_CD_FRAMESIZE), 1); if (_write_m2_image_sector (obj, buf, extent+n, 1, 0, ((n+1 < sectors) ? SM_DATA : SM_DATA |SM_EOF), 0)) break; } vcd_data_source_close (source); } static int _write_sequence (VcdObj *obj, int track_idx) { mpeg_sequence_t *track = _vcd_list_node_data (_vcd_list_at (obj->mpeg_sequence_list, track_idx)); VcdListNode *pause_node; int n, lastsect = obj->sectors_written; char buf[2324]; struct { int audio; int video; int zero; int ogt; int unknown; } mpeg_packets = {0, }; { char *norm_str = NULL; const struct vcd_mpeg_stream_vid_info *_info = &track->info->shdr[0]; switch (vcd_mpeg_get_norm (_info)) { case MPEG_NORM_PAL: norm_str = strdup ("PAL SIF (352x288/25fps)"); break; case MPEG_NORM_NTSC: norm_str = strdup ("NTSC SIF (352x240/29.97fps)"); break; case MPEG_NORM_FILM: norm_str = strdup ("FILM SIF (352x240/24fps)"); break; case MPEG_NORM_PAL_S: norm_str = strdup ("PAL 2/3 D1 (480x576/25fps)"); break; case MPEG_NORM_NTSC_S: norm_str = strdup ("NTSC 2/3 D1 (480x480/29.97fps)"); break; case MPEG_NORM_OTHER: { char buf[1024] = { 0, }; switch (_info->vsize) { case 480: case 240: snprintf (buf, sizeof (buf), "NTSC UNKNOWN (%dx%d/%2.2ffps)", _info->hsize, _info->vsize, _info->frate); break; case 288: case 576: snprintf (buf, sizeof (buf), "PAL UNKNOWN (%dx%d/%2.2ffps)", _info->hsize, _info->vsize, _info->frate); break; default: snprintf (buf, sizeof (buf), "UNKNOWN (%dx%d/%2.2ffps)", _info->hsize, _info->vsize, _info->frate); break; } norm_str = strdup (buf); } break; } { char buf[1024] = { 0, }, buf2[1024] = { 0, }; int i; for (i = 0; i < 3; i++) if (track->info->ahdr[i].seen) { const char *_mode_str[] = { 0, "stereo", "jstereo", "dual", "single", 0 }; snprintf (buf, sizeof (buf), "audio[%d]: l%d/%2.1fkHz/%dkbps/%s ", i, track->info->ahdr[i].layer, track->info->ahdr[i].sampfreq / 1000.0, track->info->ahdr[i].bitrate / 1024, _mode_str[track->info->ahdr[i].mode]); strncat (buf2, buf, sizeof(buf)); } vcd_info ("writing track %d, %s, %s, %s...", track_idx + 2, (track->info->version == MPEG_VERS_MPEG1 ? "MPEG1" : "MPEG2"), norm_str, buf2); } free (norm_str); } for (n = 0; n < obj->track_pregap; n++) _write_m2_image_sector (obj, zero, lastsect++, 0, 0, SM_FORM2, 0); for (n = 0; n < obj->track_front_margin;n++) _write_m2_image_sector (obj, zero, lastsect++, track_idx + 1, 0, SM_FORM2|SM_REALT, 0); pause_node = _vcd_list_begin (track->pause_list); for (n = 0; n < track->info->packets; n++) { int ci = 0, sm = 0, cnum = 0, fnum = 0; struct vcd_mpeg_packet_info pkt_flags; bool set_trigger = false; vcd_mpeg_source_get_packet (track->source, n, buf, &pkt_flags, obj->update_scan_offsets); while (pause_node) { pause_t *_pause = _vcd_list_node_data (pause_node); if (!pkt_flags.has_pts) break; /* no pts */ if (pkt_flags.pts < _pause->time) break; /* our time has not come yet */ /* seems it's time to trigger! */ set_trigger = true; vcd_debug ("setting auto pause trigger for time %f (pts %f) @%d", _pause->time, pkt_flags.pts, n); pause_node = _vcd_list_node_next (pause_node); } switch (vcd_mpeg_packet_get_type (&pkt_flags)) { case PKT_TYPE_VIDEO: mpeg_packets.video++; sm = SM_FORM2|SM_REALT|SM_VIDEO; ci = CI_VIDEO; cnum = CN_VIDEO; break; case PKT_TYPE_OGT: mpeg_packets.ogt++; sm = SM_FORM2|SM_REALT|SM_VIDEO; ci = CI_OGT; cnum = CN_OGT; break; case PKT_TYPE_AUDIO: mpeg_packets.audio++; sm = SM_FORM2|SM_REALT|SM_AUDIO; ci = CI_AUDIO; cnum = CN_AUDIO; if (pkt_flags.audio[1] || pkt_flags.audio[2]) { ci = CI_AUDIO2; cnum = CN_AUDIO2; } break; case PKT_TYPE_ZERO: mpeg_packets.zero++; mpeg_packets.unknown--; case PKT_TYPE_EMPTY: mpeg_packets.unknown++; sm = SM_FORM2|SM_REALT; ci = CI_EMPTY; cnum = CN_EMPTY; break; case PKT_TYPE_INVALID: vcd_error ("invalid mpeg packet found at packet# %d" " -- please fix this mpeg file!", n); vcd_mpeg_source_close (track->source); return 1; break; default: vcd_assert_not_reached (); } if (n == track->info->packets - 1) { sm |= SM_EOR; if (!obj->track_rear_margin) /* if no rear margin... */ sm |= SM_EOF; } if (set_trigger) sm |= SM_TRIG; fnum = track_idx + 1; if (_vcd_obj_has_cap_p (obj, _CAP_4C_SVCD) && !obj->svcd_vcd3_mpegav) /* IEC62107 SVCDs have a simplified subheader */ { fnum = 1; ci = CI_MPEG2; } if (_write_m2_image_sector (obj, buf, lastsect++, fnum, cnum, sm, ci)) break; } vcd_mpeg_source_close (track->source); for (n = 0; n < obj->track_rear_margin; n++) { const uint8_t ci = 0, cnum = 0; uint8_t fnum = track_idx + 1; uint8_t sm = SM_FORM2 | SM_REALT; if (n + 1 == obj->track_rear_margin) sm |= SM_EOF; _write_m2_image_sector (obj, zero, lastsect++, fnum, cnum, sm, ci); } vcd_debug ("MPEG packet statistics: %d video, %d audio, %d zero, %d ogt, %d unknown", mpeg_packets.video, mpeg_packets.audio, mpeg_packets.zero, mpeg_packets.ogt, mpeg_packets.unknown); return 0; } static int _write_segment (VcdObj *obj, mpeg_segment_t *_segment) { VcdListNode *pause_node; unsigned packet_no; int n = obj->sectors_written; vcd_assert (_segment->start_extent == n); pause_node = _vcd_list_begin (_segment->pause_list); for (packet_no = 0; packet_no < (_segment->segment_count * VCDINFO_SEGMENT_SECTOR_SIZE); packet_no++) { uint8_t buf[M2F2_SECTOR_SIZE] = { 0, }; uint8_t fn, cn, sm, ci; if (packet_no < _segment->info->packets) { struct vcd_mpeg_packet_info pkt_flags; bool set_trigger = false; bool _need_eor = false; vcd_mpeg_source_get_packet (_segment->source, packet_no, buf, &pkt_flags, obj->update_scan_offsets); fn = 1; cn = CN_EMPTY; sm = SM_FORM2 | SM_REALT; ci = CI_EMPTY; while (pause_node) { pause_t *_pause = _vcd_list_node_data (pause_node); if (!pkt_flags.has_pts) break; /* no pts */ if (pkt_flags.pts < _pause->time) break; /* our time has not come yet */ /* seems it's time to trigger! */ set_trigger = true; vcd_debug ("setting auto pause trigger for time %f (pts %f) @%d", _pause->time, pkt_flags.pts, n); pause_node = _vcd_list_node_next (pause_node); } switch (vcd_mpeg_packet_get_type (&pkt_flags)) { case PKT_TYPE_VIDEO: sm = SM_FORM2 | SM_REALT | SM_VIDEO; ci = CI_VIDEO; cn = CN_VIDEO; if (pkt_flags.video[1]) ci = CI_STILL, cn = CN_STILL; else if (pkt_flags.video[2]) ci = CI_STILL2, cn = CN_STILL2; if (pkt_flags.video[1] || pkt_flags.video[2]) { /* search for endcode -- hack */ int idx; for (idx = 0; idx <= 2320; idx++) if (buf[idx] == 0x00 && buf[idx + 1] == 0x00 && buf[idx + 2] == 0x01 && buf[idx + 3] == 0xb7) { _need_eor = true; break; } } break; case PKT_TYPE_AUDIO: sm = SM_FORM2 | SM_REALT | SM_AUDIO; ci = CI_AUDIO; cn = CN_AUDIO; break; case PKT_TYPE_EMPTY: ci = CI_EMPTY; cn = CN_EMPTY; break; default: /* fixme -- check.... */ break; } if (_vcd_obj_has_cap_p (obj, _CAP_4C_SVCD)) { cn = 1; sm = SM_FORM2 | SM_REALT | SM_VIDEO; ci = CI_MPEG2; } if (packet_no + 1 == _segment->info->packets) sm |= SM_EOF; if (set_trigger) sm |= SM_TRIG; if (_need_eor) { vcd_debug ("setting EOR for SeqEnd at packet# %d ('%s')", packet_no, _segment->id); sm |= SM_EOR; } } else { fn = 1; cn = CN_EMPTY; sm = SM_FORM2 | SM_REALT; ci = CI_EMPTY; if (_vcd_obj_has_cap_p (obj, _CAP_4C_SVCD)) { fn = 0; sm = SM_FORM2; } } _write_m2_image_sector (obj, buf, n, fn, cn, sm, ci); n++; } vcd_mpeg_source_close (_segment->source); return 0; } static uint32_t _get_closest_aps (const struct vcd_mpeg_stream_info *_mpeg_info, double t, struct aps_data *_best_aps) { VcdListNode *node; struct aps_data best_aps; bool first = true; vcd_assert (_mpeg_info != NULL); vcd_assert (_mpeg_info->shdr[0].aps_list != NULL); _VCD_LIST_FOREACH (node, _mpeg_info->shdr[0].aps_list) { struct aps_data *_aps = _vcd_list_node_data (node); if (first) { best_aps = *_aps; first = false; } else if (fabs (_aps->timestamp - t) < fabs (best_aps.timestamp - t)) best_aps = *_aps; else break; } if (_best_aps) *_best_aps = best_aps; return best_aps.packet_no; } static void _update_entry_points (VcdObj *obj) { VcdListNode *sequence_node; _VCD_LIST_FOREACH (sequence_node, obj->mpeg_sequence_list) { mpeg_sequence_t *_sequence = _vcd_list_node_data (sequence_node); VcdListNode *entry_node; unsigned last_packet_no = 0; _VCD_LIST_FOREACH (entry_node, _sequence->entry_list) { entry_t *_entry = _vcd_list_node_data (entry_node); _get_closest_aps (_sequence->info, _entry->time, &_entry->aps); vcd_log ((fabs (_entry->aps.timestamp - _entry->time) > 1 ? VCD_LOG_WARN : VCD_LOG_DEBUG), "requested entry point (id=%s) at %f, " "closest possible entry point at %f", _entry->id, _entry->time, _entry->aps.timestamp); if (last_packet_no == _entry->aps.packet_no) vcd_warn ("entry point '%s' falls into same sector as previous one!", _entry->id); last_packet_no = _entry->aps.packet_no; } } } static int _write_vcd_iso_track (VcdObj *obj, const time_t *create_time) { VcdListNode *node; int n; /* generate dir sectors */ _vcd_directory_dump_entries (obj->dir, _dict_get_bykey (obj, "dir")->buf, _dict_get_bykey (obj, "dir")->sector); _vcd_directory_dump_pathtables (obj->dir, _dict_get_bykey (obj, "ptl")->buf, _dict_get_bykey (obj, "ptm")->buf); /* generate PVD and EVD at last... */ iso9660_set_pvd (_dict_get_bykey (obj, "pvd")->buf, obj->iso_volume_label, obj->iso_publisher_id, obj->iso_preparer_id, obj->iso_application_id, obj->iso_size, _dict_get_bykey (obj, "dir")->buf, _dict_get_bykey (obj, "ptl")->sector, _dict_get_bykey (obj, "ptm")->sector, iso9660_pathtable_get_size (_dict_get_bykey (obj, "ptm")->buf), create_time ); iso9660_set_evd (_dict_get_bykey (obj, "evd")->buf); /* fill VCD relevant files with data */ set_info_vcd (obj, _dict_get_bykey (obj, "info")->buf); set_entries_vcd (obj, _dict_get_bykey (obj, "entries")->buf); if (_vcd_pbc_available (obj)) { if (_vcd_obj_has_cap_p (obj, _CAP_PBC_X)) { set_lot_vcd (obj, _dict_get_bykey (obj, "lot_x")->buf, true); set_psd_vcd (obj, _dict_get_bykey (obj, "psd_x")->buf, true); } _vcd_pbc_check_unreferenced (obj); set_lot_vcd (obj, _dict_get_bykey (obj, "lot")->buf, false); set_psd_vcd (obj, _dict_get_bykey (obj, "psd")->buf, false); } if (_vcd_obj_has_cap_p (obj, _CAP_4C_SVCD)) { set_tracks_svd (obj, _dict_get_bykey (obj, "tracks")->buf); set_search_dat (obj, _dict_get_bykey (obj, "search")->buf); set_scandata_dat (obj, _dict_get_bykey (obj, "scandata")->buf); } /* start actually writing stuff */ vcd_info ("writing track 1 (ISO9660)..."); /* 00:02:00 -> 00:04:74 */ for (n = 0;n < obj->mpeg_segment_start_extent; n++) { const void *content = NULL; uint8_t flags = SM_DATA; content = _dict_get_sector (obj, n); flags |= _dict_get_sector_flags (obj, n); if (content == NULL) content = zero; _write_m2_image_sector (obj, content, n, 0, 0, flags, 0); } /* SEGMENTS */ vcd_assert (n == obj->mpeg_segment_start_extent); _VCD_LIST_FOREACH (node, obj->mpeg_segment_list) { mpeg_segment_t *_segment = _vcd_list_node_data (node); _write_segment (obj, _segment); } n = obj->sectors_written; /* EXT stuff */ vcd_assert (n == obj->ext_file_start_extent); for (;n < obj->custom_file_start_extent; n++) { const void *content = NULL; uint8_t flags = SM_DATA; uint8_t fileno = _vcd_obj_has_cap_p (obj, _CAP_4C_SVCD) ? 0 : 1; content = _dict_get_sector (obj, n); flags |= _dict_get_sector_flags (obj, n); if (content == NULL) { vcd_debug ("unexpected empty EXT sector"); content = zero; } _write_m2_image_sector (obj, content, n, fileno, 0, flags, 0); } /* write custom files */ vcd_assert (n == obj->custom_file_start_extent); _VCD_LIST_FOREACH (node, obj->custom_file_list) { custom_file_t *p = _vcd_list_node_data (node); vcd_info ("writing file `%s' (%d bytes%s)", p->iso_pathname, p->size, p->raw_flag ? ", raw sectors file": ""); if (p->raw_flag) _write_source_mode2_raw (obj, p->file, p->start_extent); else _write_source_mode2_form1 (obj, p->file, p->start_extent); } /* blank unalloced tracks */ while ((n = _vcd_salloc (obj->iso_bitmap, SECTOR_NIL, 1)) < obj->iso_size) _write_m2_image_sector (obj, zero, n, 0, 0, SM_DATA, 0); return 0; } long vcd_obj_get_image_size (VcdObj *obj) { long size_sectors = -1; vcd_assert (!obj->in_output); if (_vcd_list_length (obj->mpeg_sequence_list) > 0) { /* fixme -- make this efficient */ size_sectors = vcd_obj_begin_output (obj); vcd_obj_end_output (obj); } return size_sectors; } long vcd_obj_begin_output (VcdObj *obj) { uint32_t image_size; vcd_assert (obj != NULL); vcd_assert (_vcd_list_length (obj->mpeg_sequence_list) > 0); vcd_assert (!obj->in_output); obj->in_output = true; obj->in_track = 1; obj->sectors_written = 0; obj->iso_bitmap = _vcd_salloc_new (); obj->dir = _vcd_directory_new (); obj->buffer_dict_list = _vcd_list_new (); _finalize_vcd_iso_track (obj); _update_entry_points (obj); image_size = obj->relative_end_extent + obj->iso_size; image_size += obj->leadout_pregap; if (image_size > CDIO_CD_MAX_SECTORS) vcd_error ("image too big (%d sectors > %d sectors)", (unsigned) image_size, (unsigned) CDIO_CD_MAX_SECTORS); { char *_tmp = cdio_lba_to_msf_str (image_size); if (image_size > CDIO_CD_74MIN_SECTORS) vcd_warn ("generated image (%d sectors [%s]) may not fit " "on 74min CDRs (%d sectors)", (unsigned) image_size, _tmp, (unsigned) CDIO_CD_74MIN_SECTORS); free (_tmp); } return image_size; } void vcd_obj_end_output (VcdObj *obj) { vcd_assert (obj != NULL); vcd_assert (obj->in_output); obj->in_output = false; _vcd_directory_destroy (obj->dir); _vcd_salloc_destroy (obj->iso_bitmap); _dict_clean (obj); _vcd_list_free (obj->buffer_dict_list, true); } int vcd_obj_append_pbc_node (VcdObj *obj, struct _pbc_t *_pbc) { vcd_assert (obj != NULL); vcd_assert (_pbc != NULL); if (!_vcd_obj_has_cap_p (obj, _CAP_PBC)) { vcd_error ("PBC not supported for current VCD type"); return -1; } if (_pbc->item_id && _vcd_pbc_lookup (obj, _pbc->item_id)) { vcd_error ("item id (%s) exists already", _pbc->item_id); return -1; } _vcd_list_append (obj->pbc_list, _pbc); return 0; } int vcd_obj_write_image (VcdObj *obj, VcdImageSink *image_sink, progress_callback_t callback, void *user_data, const time_t *create_time) { VcdListNode *node; vcd_assert (obj != NULL); vcd_assert (obj->in_output); if (!image_sink) return -1; /* start with meta info */ { VcdList *cue_list; vcd_cue_t *_cue; cue_list = _vcd_list_new (); _vcd_list_append (cue_list, (_cue = _vcd_malloc (sizeof (vcd_cue_t)))); _cue->lsn = 0; _cue->type = VCD_CUE_TRACK_START; _VCD_LIST_FOREACH (node, obj->mpeg_sequence_list) { mpeg_sequence_t *track = _vcd_list_node_data (node); VcdListNode *entry_node; _vcd_list_append (cue_list, (_cue = _vcd_malloc (sizeof (vcd_cue_t)))); _cue->lsn = track->relative_start_extent + obj->iso_size; _cue->lsn -= obj->track_pregap; _cue->type = VCD_CUE_PREGAP_START; _vcd_list_append (cue_list, (_cue = _vcd_malloc (sizeof (vcd_cue_t)))); _cue->lsn = track->relative_start_extent + obj->iso_size; _cue->type = VCD_CUE_TRACK_START; _VCD_LIST_FOREACH (entry_node, track->entry_list) { entry_t *_entry = _vcd_list_node_data (entry_node); _vcd_list_append (cue_list, (_cue = _vcd_malloc (sizeof (vcd_cue_t)))); _cue->lsn = obj->iso_size; _cue->lsn += track->relative_start_extent; _cue->lsn += obj->track_front_margin; _cue->lsn += _entry->aps.packet_no; _cue->type = VCD_CUE_SUBINDEX; } } /* add last one... */ _vcd_list_append (cue_list, (_cue = _vcd_malloc (sizeof (vcd_cue_t)))); _cue->lsn = obj->relative_end_extent + obj->iso_size; _cue->lsn += obj->leadout_pregap; _cue->type = VCD_CUE_END; /* send it to image object */ vcd_image_sink_set_cuesheet (image_sink, cue_list); _vcd_list_free (cue_list, true); } /* and now for the pay load */ { unsigned track; vcd_assert (obj != NULL); vcd_assert (obj->sectors_written == 0); vcd_assert (obj->in_output); obj->progress_callback = callback; obj->callback_user_data = user_data; obj->image_sink = image_sink; if (_callback_wrapper (obj, true)) return 1; if (_write_vcd_iso_track (obj, create_time)) return 1; if (obj->update_scan_offsets) vcd_info ("'update scan offsets' option enabled for the following tracks!"); for (track = 0;track < _vcd_list_length (obj->mpeg_sequence_list);track++) { obj->in_track++; if (_callback_wrapper (obj, true)) return 1; if (_write_sequence (obj, track)) return 1; } if (obj->leadout_pregap) { int n, lastsect = obj->sectors_written; vcd_debug ("writting post-gap ('leadout pregap')..."); for (n = 0; n < obj->leadout_pregap; n++) _write_m2_image_sector (obj, zero, lastsect++, 0, 0, SM_FORM2, 0); } if (_callback_wrapper (obj, true)) return 1; obj->image_sink = NULL; vcd_image_sink_destroy (image_sink); return 0; /* ok */ } } const char * vcd_version_string (bool full_text) { if (!full_text) return ("GNU VCDImager " VERSION " [" HOST_ARCH "]"); return ("%s (GNU VCDImager) " VERSION "\n" "Written by Herbert Valerio Riedel and Rocky Bernstein.\n" "\n" "http://www.gnu.org/software/vcdimager/\n" "\n" "Copyright (C) 2000-2003 Herbert Valerio Riedel \n" " 2003 Rocky Bernstein \n" "\n" "This is free software; see the source for copying conditions. There is NO\n" "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"); } /* * Local variables: * c-file-style: "gnu" * tab-width: 8 * indent-tabs-mode: nil * End: */