4 * Copyright (C) 2009 Adam Williams <broadcast at earthling dot net>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include "arraylist.h"
28 #include "indexfile.h"
29 #include "indexstate.h"
31 #include "mainerror.h"
37 int IndexMarks::find(int64_t no)
39 int l = -1, r = size();
40 while( (r - l) > 1 ) {
42 if( no > values[i].no ) l = i; else r = i;
47 IndexChannel::IndexChannel(IndexState *state, int64_t length)
50 this->length = length;
57 IndexChannel::~IndexChannel()
62 void IndexChannel::put_entry()
71 int64_t IndexChannel::pos()
73 return used() * state->index_zoom + zidx;
76 void IndexChannel::pad_data(int64_t pos)
78 CLAMP(pos, 0, length);
79 while( this->pos() < pos ) put_entry();
80 inp = bfr + pos / state->index_zoom;
81 zidx = pos % state->index_zoom;
84 void IndexState::reset_index()
86 index_status = INDEX_NOTTESTED;
90 index_entries.remove_all_objects();
91 index_channels.remove_all_objects();
94 void IndexState::reset_markers()
96 marker_status = MARKERS_NOTTESTED;
97 video_markers.remove_all_objects();
98 audio_markers.remove_all_objects();
101 IndexState::IndexState()
102 : Garbage("IndexState")
104 marker_lock = new Mutex("IndexState::marker_lock");
109 IndexState::~IndexState()
116 void IndexState::init_scan(int64_t index_length)
119 int channels = index_channels.size();
120 if( !channels ) return;
121 int64_t max_samples = 0;
122 for( int ch=0; ch<channels; ++ch ) {
123 int64_t len = index_channels[ch]->length;
124 if( max_samples < len ) max_samples = len;
126 int64_t items = index_length / sizeof(IndexItem);
127 int64_t count = (items - channels) / channels + 1;
128 while( count*index_zoom < max_samples ) index_zoom *= 2;
129 for( int ch=0; ch<channels; ++ch ) {
130 IndexChannel *chn = index_channels[ch];
131 int64_t len = chn->length / index_zoom + 1;
138 void IndexState::dump()
140 printf("IndexState::dump this=%p\n", this);
141 printf(" index_status=%d index_zoom=" _LD " index_bytes=" _LD "\n",
142 index_status, index_zoom, index_bytes);
143 printf(" index entries=%d\n", index_entries.size());
144 for( int i=0; i<index_entries.size(); ++i )
145 printf(" %d. ofs=" _LD ", sz=" _LD "\n", i,
146 index_entries[i]->offset, index_entries[i]->size);
150 void IndexState::write_xml(FileXML *file)
152 file->tag.set_title("INDEX");
153 file->tag.set_property("ZOOM", index_zoom);
154 file->tag.set_property("BYTES", index_bytes);
156 file->append_newline();
158 for( int i=0; i<index_entries.size(); ++i ) {
159 file->tag.set_title("OFFSET");
160 file->tag.set_property("FLOAT", index_entries[i]->offset);
162 file->tag.set_title("SIZE");
163 file->tag.set_property("FLOAT", index_entries[i]->size);
167 file->append_newline();
168 file->tag.set_title("/INDEX");
170 file->append_newline();
173 void IndexState::read_xml(FileXML *file, int channels)
175 index_entries.remove_all_objects();
176 for( int i=0; i<channels; ++i ) add_index_entry(0, 0, 0);
178 int current_offset = 0;
179 int current_size = 0;
182 index_zoom = file->tag.get_property("ZOOM", 1);
183 index_bytes = file->tag.get_property("BYTES", (int64_t)0);
186 result = file->read_tag();
188 if(file->tag.title_is("/INDEX")) {
191 else if(file->tag.title_is("OFFSET")) {
192 if(current_offset < channels) {
193 int64_t offset = file->tag.get_property("FLOAT", (int64_t)0);
194 index_entries[current_offset++]->offset = offset;
195 //printf("Asset::read_index %d %d\n", current_offset - 1, index_offsets[current_offset - 1]);
198 else if(file->tag.title_is("SIZE")) {
199 if(current_size < channels) {
200 int64_t size = file->tag.get_property("FLOAT", (int64_t)0);
201 index_entries[current_size++]->size = size;
208 int IndexState::write_index(const char *index_path, Asset *asset, int64_t zoom, int64_t file_bytes)
210 FILE *fp = fopen(index_path, "wb");
212 eprintf(_("IndexState::write_index Couldn't write index file %s to disk.\n"),
217 index_bytes = file_bytes;
218 index_status = INDEX_READY;
221 // write index_state as asset or directly.
223 asset->write(&xml, 1, "");
226 int64_t len = xml.length() + FileXML::xml_header_size;
227 index_start = sizeof(index_start) + len;
228 fwrite(&index_start, sizeof(index_start), 1, fp);
229 xml.write_to_file(fp);
231 int channels = index_entries.size();
232 int64_t max_size = 0;
233 for( int ch=0; ch<channels; ++ch ) {
234 IndexEntry *ent = index_entries[ch];
235 float *bfr = ent->bfr;
236 int64_t size = ent->size;
237 if( max_size < size ) max_size = size;
238 fwrite(bfr, sizeof(float), size, fp);
246 int IndexState::write_markers(const char *index_path)
248 int vid_size = video_markers.size();
249 int aud_size = audio_markers.size();
250 if( !vid_size && !aud_size ) return 0;
253 char marker_path[BCTEXTLEN];
254 strcpy(marker_path, index_path);
255 char *basename = strrchr(marker_path,'/');
256 if( !basename ) basename = marker_path;
257 char *ext = strrchr(basename, '.');
260 fp = fopen(marker_path, "wb");
263 char version[] = MARKER_MAGIC_VERSION;
264 if( !fp || !fwrite(version, strlen(version), 1, fp) ) {
265 eprintf(_("IndexState::write_markers Couldn't write marker file %s to disk.\n"),
270 fwrite(&vid_size, sizeof(vid_size), 1, fp);
271 for( int vidx=0; vidx<vid_size; ++vidx ) {
272 IndexMarks &marks = *video_markers[vidx];
273 int count = marks.size();
274 fwrite(&count, sizeof(count), 1, fp);
275 fwrite(&marks[0], sizeof(marks[0]), count, fp);
278 fwrite(&aud_size, sizeof(aud_size), 1, fp);
279 for( int aidx=0; aidx<aud_size; ++aidx ) {
280 IndexMarks &marks = *audio_markers[aidx];
281 int count = marks.size();
282 fwrite(&count, sizeof(count), 1, fp);
283 fwrite(&marks[0], sizeof(marks[0]), marks.size(), fp);
290 int IndexState::read_markers(char *index_dir, char *file_path)
293 marker_lock->lock("IndexState::read_markers");
294 if( marker_status == MARKERS_NOTTESTED ) {
295 char src_path[BCTEXTLEN], marker_path[BCTEXTLEN];
296 IndexFile::get_index_filename(src_path, index_dir, marker_path, file_path, ".mkr");
297 FILE *fp = fopen(marker_path, "rb");
298 int vsz = strlen(MARKER_MAGIC_VERSION);
300 if( fp && fread(version, vsz, 1, fp) ) {
301 if( memcmp(version, MARKER_MAGIC_VERSION, vsz) ) {
302 eprintf(_("IndexState::read_markers marker file version mismatched\n: %s\n"),
306 ret = read_marks(fp);
307 if( !ret ) marker_status = MARKERS_READY;
311 marker_lock->unlock();
315 int IndexState::read_marks(FILE *fp)
319 if( !fread(&vid_size, sizeof(vid_size), 1, fp) ) return 1;
320 add_video_markers(vid_size);
321 for( int vidx=0; vidx<vid_size; ++vidx ) {
323 if( !fread(&count, sizeof(count), 1, fp) ) return 1;
324 IndexMarks &marks = *video_markers[vidx];
325 marks.allocate(count);
326 int len = fread(&marks[0], sizeof(marks[0]), count, fp);
327 if( len != count ) return 1;
331 if( !fread(&aud_size, sizeof(aud_size), 1, fp) ) return 1;
332 add_audio_markers(aud_size);
333 for( int aidx=0; aidx<aud_size; ++aidx ) {
335 if( !fread(&count, sizeof(count), 1, fp) ) return 1;
336 IndexMarks &marks = *audio_markers[aidx];
337 marks.allocate(count);
338 int len = fread(&marks[0], sizeof(marks[0]), count, fp);
339 if( len != count ) return 1;
345 int IndexState::create_index(const char *index_path, Asset *asset)
347 index_entries.remove_all_objects();
348 int channels = index_channels.size();
350 for( int ch=0; ch<channels; ++ch ) {
351 IndexChannel *chn = index_channels[ch];
352 float *bfr = (float *)chn->bfr;
353 int64_t size = 2 * chn->used();
354 add_index_entry(bfr, offset, size);
358 write_markers(index_path);
359 return write_index(index_path, asset, index_zoom, index_bytes);
362 int64_t IndexState::get_index_offset(int channel)
364 return channel >= index_entries.size() ? 0 :
365 index_entries[channel]->offset;
368 int64_t IndexState::get_index_size(int channel)
370 return channel >= index_entries.size() ? 0 :
371 index_entries[channel]->size;
374 float *IndexState::get_channel_buffer(int channel)
376 return channel >= index_channels.size() ? 0 :
377 (float *)index_channels[channel]->bfr;
380 int64_t IndexState::get_channel_used(int channel)
382 return channel >= index_channels.size() ? 0 :
383 index_channels[channel]->used();