add bluray dv, misc fixes
[goodguy/history.git] / cinelerra-5.1 / cinelerra / mediadb.C
1 #include <stdio.h>
2 #include <stdarg.h>
3 #include <stdlib.h>
4 #include <unistd.h>
5 #include <string.h>
6 #include <limits.h>
7 #include <time.h>
8
9 #include "../db/tdb.h"
10 #include "../db/s.C"
11
12 #include "linklist.h"
13 #include "mediadb.h"
14 #include "filexml.h"
15
16
17
18 void write_pgm(uint8_t *tp, int w, int h, const char *fmt, ...)
19 {
20   va_list ap;    va_start(ap, fmt);
21   char fn[256];  vsnprintf(fn, sizeof(fn), fmt, ap);
22   va_end(ap);
23   FILE *fp = !strcmp(fn,"-") ? stdout : fopen(fn,"w");
24   if( fp ) {
25     fprintf(fp,"P5\n%d %d\n255\n",w,h);
26     fwrite(tp,w,h,fp);
27     fclose(fp);
28   }
29 }
30
31 void write_ppm(uint8_t *tp, int w, int h, const char *fmt, ...)
32 {
33   va_list ap;    va_start(ap, fmt);
34   char fn[256];  vsnprintf(fn, sizeof(fn), fmt, ap);
35   va_end(ap);
36   FILE *fp = !strcmp(fn,"-") ? stdout : fopen(fn,"w");
37   if( fp ) {
38     fprintf(fp,"P6\n%d %d\n255\n",w,h);
39     fwrite(tp,3*w,h,fp);
40     fclose(fp);
41   }
42 }
43
44 static inline int clip(int v, int mn, int mx)
45 {
46   return v<mn ? mn : v>mx ? mx : v;
47 }
48
49 void pbm_diff(uint8_t *ap, uint8_t *bp, int w, int h, const char *fmt, ...)
50 {
51   va_list va;    va_start(va, fmt);
52   char fn[256];  vsnprintf(fn, sizeof(fn), fmt, va);
53   va_end(va);
54   FILE *fp = !strcmp(fn,"-") ? stdout : fopen(fn,"w");
55   if( fp ) {
56     int sz = w*h;
57     uint8_t dat[sz], *dp = dat;
58     for( int i=sz; --i>=0; ++dp,++ap,++bp ) *dp = clip(*ap-*bp+128, 0 ,255);
59     fprintf(fp,"P5\n%d %d\n255\n",w,h);
60     fwrite(dat,w,h,fp);
61     fclose(fp);
62   }
63 }
64
65
66 void Scale::
67 scale(uint8_t *odata, int ow, int oh, int sx, int sy, int sw, int sh)
68 {
69   pw = (double)(ow * oh) / (rw * rh);
70   odat = odata + sy*ow + sx;
71   iy1 = 0;  yf1 = 0;
72   double r = 0.5;
73
74   for( int dy=1; dy<=sh; ++dy, odat+=ow ) {
75     iy0 = iy1;  yf0 = 1.0 - yf1;
76     double ny = (double)(dy * rh) / oh;
77     iy1 = (int) ny;  yf1 = ny-iy1;
78     uint8_t *bp = odat;
79     ix1 = 0;  xf1 = 0;
80
81     for( int dx=1; dx<=sw; ++dx ) {
82       ix0 = ix1;  xf0 = 1.0 - xf1;
83       double nx = (double)(dx*rw) / ow;
84       ix1 = (int)nx;  xf1 = nx-ix1;
85       double px = scalexy();
86       int ipx = px + r;
87       r += px - ipx;
88       *bp++ = ipx;
89     }
90   }
91 }
92
93
94 Deletions::
95 Deletions(int pid, const char *fn)
96 {
97         this->pid = pid;
98         strcpy(this->filepath,fn);
99 }
100
101 Deletions::
102 ~Deletions()
103 {
104 }
105
106
107 int Deletions::
108 load(FileXML &xml)
109 {
110         for(;;) {
111                 if( xml.read_tag() != 0 ) return 1;
112                 if( !xml.tag.title_is("DEL") ) break;
113                 double time = xml.tag.get_property("TIME", (double)0.0);
114                 int action = xml.tag.get_property("ACTION", (int)0);
115                 append(new Dele(time, action));
116         }
117         return 0;
118 }
119
120 Deletions *Deletions::
121 read_dels(const char *filename)
122 {
123         FileXML xml;
124         if( xml.read_from_file(filename, 1) ) return 0;
125         do {
126                 if( xml.read_tag() ) return 0;
127         } while( !xml.tag.title_is("DELS") );
128
129         int pid = xml.tag.get_property("PID", (int)-1);
130         const char *file = xml.tag.get_property("FILE");
131         Deletions *dels = new Deletions(pid, file);
132         if( dels->load(xml) || !xml.tag.title_is("/DELS") ) {
133                  delete dels; dels = 0;
134         }
135         return dels;
136 }
137
138 int Deletions::
139 save(FileXML &xml)
140 {
141         xml.tag.set_title("DELS");
142         xml.tag.set_property("PID", pid);
143         xml.tag.set_property("FILE", filepath);
144         xml.append_tag();
145         xml.append_newline();
146
147         for( Dele *del=first; del; del=del->next ) {
148                 xml.tag.set_title("DEL");
149                 xml.tag.set_property("TIME", del->time);
150                 xml.tag.set_property("ACTION", del->action);
151                 xml.append_tag();
152                 xml.tag.set_title("/DEL");
153                 xml.append_tag();
154                 xml.append_newline();
155         }
156
157         xml.tag.set_title("/DELS");
158         xml.append_tag();
159         xml.append_newline();
160         return 0;
161 }
162
163 int Deletions::
164 write_dels(const char *filename)
165 {
166         FILE *fp = fopen(filename, "wb");
167         if( !fp != 0 ) return 1;
168         FileXML xml;
169         save(xml);
170         xml.terminate_string();
171         xml.write_to_file(fp);
172         fclose(fp);
173         return 0;
174 }
175
176
177 Clip::
178 Clip(int clip_id, double start, double end, int index)
179 {
180         this->clip_id = clip_id;
181         this->start = start;
182         this->end = end;
183         this->index = index;
184         this->votes = 0;
185         this->groups = 0;
186         this->cycle = 0;
187         this->muted = 0;
188         this->best = 1.e99;
189 }
190
191 Clip::
192 ~Clip()
193 {
194         Clips *clips = (Clips *)list;
195         if( clips && clips->current == this ) clips->current = 0;
196 }
197
198 Clip *Clips::locate(int id, double start, double end)
199 {
200         if( current && current->clip_id == id &&
201             end >= current->start && start < current->end )
202                 return current;
203         for( current=first; current!=0; current=current->next ) {
204                 if( current->clip_id != id ) continue;
205                 if( current->start <= end && current->end > start ) break;
206         }
207         return current;
208 }
209
210 Clips::
211 Clips(int pid)
212 {
213         this->pid = pid;
214         this->current = 0;
215         this->count = 0;
216         this->cycle = 0;
217 }
218
219 Clips::
220 ~Clips()
221 {
222 }
223
224 Clip *Clips::
225 new_clip(int clip_id, double start, double end, int index)
226 {
227         return append(new Clip(clip_id, start, end, index));
228 }
229
230 int Clips::
231 get_clip(int idx, int &id, double &start, double &end)
232 {
233         int votes = -1, cid = -1;
234         double st = 0, et = 0;
235
236         for( Clip *clip=first; clip!=0; clip=clip->next ) {
237                 if( clip->index != idx ) continue;
238                 // must have prefix+suffix frames
239                 if( clip->groups != 3 ) continue;
240                 if( clip->votes < votes ) continue;
241                 if( clip->votes > votes ) {
242                         // first/better match
243                         votes = clip->votes;
244                         cid = clip->clip_id;
245                         st = clip->start;
246                         et = clip->end;
247                         continue;
248                 }
249                 // reject if not overlapping
250                 if( clip->start > et ) continue;
251                 if( clip->end < st ) continue;
252                 // expand range on overlap
253                 if( clip->start < st ) st = clip->start;
254                 if( clip->end > et ) et = clip->end;
255         }
256
257         if( votes > 2 ) {
258                 start = st;  end = et;  id = cid;
259                 return 1;
260         }
261
262         return 0;
263 }
264
265 int Clips::
266 check(int clip_id, double start, double end, int group, double err)
267 {
268         Clip *clip = locate(clip_id, start, end);
269         if( clip ) {
270                 if( err < clip->best ) {
271                         clip->best = err;
272                         if( start < clip->start ) clip->start = start;
273                         if( end > clip->end ) clip->end = end;
274                 }
275         }
276         else
277                 clip = new_clip(clip_id, start, end, count++);
278         clip->groups |= group;
279         if( cycle != clip->cycle ) {
280                  clip->cycle = cycle;
281                 ++clip->votes;
282 //printf("clip %d votes %d\n",clip_id,clip->votes);
283         }
284         return 0;
285 }
286
287 int Clips::
288 save(FileXML &xml)
289 {
290         xml.tag.set_title("CLIPS");
291         xml.tag.set_property("PID", pid);
292         xml.append_tag();
293         xml.append_newline();
294
295         for( int idx=0; idx<count; ++idx ) {
296                 int id;  double start, end;
297                 if( !get_clip(idx, id, start, end) ) continue;
298                 xml.tag.set_title("CLIP");
299                 xml.tag.set_property("ID", id);
300                 xml.tag.set_property("START", start);
301                 xml.tag.set_property("END", end);
302                 xml.append_tag();
303                 xml.tag.set_title("/CLIP");
304                 xml.append_tag();
305                 xml.append_newline();
306         }
307
308         xml.tag.set_title("/CLIPS");
309         xml.append_tag();
310         xml.append_newline();
311         return 0;
312 }
313
314 int Clips::
315 load(FileXML &xml)
316 {
317         int i = 0;
318         for(;;) {
319                 if( xml.read_tag() != 0 ) return 1;
320                 if( !xml.tag.title_is("CLIP") ) break;
321                 int clip_id = xml.tag.get_property("ID", (int)0);
322                 double start = xml.tag.get_property("START", (double)0.0);
323                 double end = xml.tag.get_property("END", (double)0.0);
324                 append(new Clip(clip_id, start, end, i++));
325         }
326         count = i;
327         return 0;
328 }
329
330
331 Snip::
332 Snip(int clip_id, double start, double end, int index)
333  : Clip(clip_id, start, end, index)
334 {
335 }
336
337 Snip::
338 ~Snip()
339 {
340 }
341
342 Snips::
343 Snips()
344 {
345 }
346
347 Snips::
348 ~Snips()
349 {
350 }
351
352 Clip *Snips::
353 new_clip(int clip_id, double start, double end, int index)
354 {
355         return append(new Snip(clip_id, start, end, index));
356 }
357
358
359 MediaDb::
360 MediaDb()
361 {
362         opened = 0;
363         db = new theDb();
364 }
365
366 MediaDb::
367 ~MediaDb()
368 {
369         if( opened ) closeDb();
370         delete db;
371 }
372
373 int MediaDb::is_open() { return opened > 0 ? opened : 0; }
374 int MediaDb::transaction() { return db->transaction(); }
375
376 // clip_set accessors
377 int MediaDb::clip_id(int id) { return db->clip_set.FindId(id); }
378 int MediaDb::clip_id() { return db->clip_set.id(); }
379 int MediaDb::clips_first_id() { return db->clip_set.FirstId(clip_id_loc); }
380 int MediaDb::clips_next_id() { return db->clip_set.NextId(clip_id_loc); }
381 const char *MediaDb::clip_title() { return db->clip_set.Title(); }
382 const char *MediaDb::clip_path() { return db->clip_set.Asset_path(); }
383 double MediaDb::clip_position() { return db->clip_set.Position(); }
384 double MediaDb::clip_framerate() { return db->clip_set.Framerate(); }
385 double MediaDb::clip_average_weight() { return db->clip_set.Average_weight(); }
386 void MediaDb::clip_average_weight(double avg_wt) { return db->clip_set.Average_weight(avg_wt); }
387 int MediaDb::clip_frames() { return db->clip_set.Frames(); }
388 double MediaDb::clip_length() {
389         return clip_framerate()>0 ? clip_frames() / clip_framerate() : 0;
390 }
391 int MediaDb::clip_prefix_size() { return db->clip_set.Prefix_size(); }
392 int MediaDb::clip_suffix_size() { return db->clip_set.Suffix_size(); }
393 int MediaDb::clip_size() { return clip_prefix_size()+clip_suffix_size(); }
394 double *MediaDb::clip_weights() { return (double *)db->clip_set._Weights(); }
395 int64_t MediaDb::clip_creation_time() { return db->clip_set.Creation_time(); }
396 int64_t MediaDb::clip_system_time() { return db->clip_set.System_time(); }
397
398 // MediaDb::timeline accessors
399 int MediaDb::timeline_id(int id) { return db->timeline.FindId(id); }
400 int MediaDb::timeline_id() { return db->timeline.id(); }
401 int MediaDb::timeline_clip_id() { return db->timeline.Clip_id(); }
402 int MediaDb::timeline_sequence_no() { return db->timeline.Sequence_no(); }
403 int MediaDb::timeline_frame_id() { return db->timeline.Frame_id(); }
404 int MediaDb::timeline_group() { return db->timeline.Group(); }
405 double MediaDb::timeline_offset() { return db->timeline.Time_offset(); }
406
407 // MediaDb::clip_view accessors
408 int MediaDb::views_id(int id) { return db->clip_views.FindId(id); }
409 int MediaDb::views_id() { return db->clip_views.id(); }
410 int MediaDb::views_clip_id(int id) {
411         return Clip_viewsLoc::ikey_Clip_access(db->clip_views,id).Find();
412 }
413 int MediaDb::views_clip_id() { return db->clip_views.Access_clip_id(); }
414 int64_t MediaDb::views_access_time() { return db->clip_views.Access_time(); }
415 int MediaDb::views_access_count() { return db->clip_views.Access_count(); }
416
417
418 double MediaDb::
419 mean(uint8_t *dat, int n, int stride)
420 {
421   int s = 0;
422   for( int i=0; i<n; ++i, dat+=stride ) s += *dat;
423   return (double)s / n;
424 }
425
426 double MediaDb::
427 variance(uint8_t *dat, double m, int n, int stride)
428 {
429   double ss = 0, s = 0;
430   for( int i=0; i<n; ++i, dat+=stride ) {
431     double dx = *dat-m;
432     s += dx;  ss += dx*dx;
433   }
434   return (ss - s*s / n) / (n-1);
435 }
436
437 double MediaDb::
438 centroid(uint8_t *dat, int n, int stride)
439 {
440   int s = 0, ss = 0;
441   for( int i=0; i<n; dat+=stride ) { s += *dat;  ss += ++i * *dat; }
442   return s > 0 ? (double)ss / s : n / 2.;
443 }
444
445 void MediaDb::
446 centroid(uint8_t *dat, int w, int h, double &xx, double &yy)
447 {
448         double x = 0, y = 0;
449         uint8_t *dp = dat;
450         for( int i=h; --i>=0; dp+=w ) x += centroid(dp, w);
451         for( int i=w; --i>=0; ) y += centroid(dat+i, h, w);
452         xx = x / h;  yy = y / w;
453 }
454
455 void MediaDb::
456 deviation(uint8_t *a, uint8_t *b, int sz, int margin,
457                 double &dev, int &ofs, int stride)
458 {
459   double best = 1e100;  int ii = -1;
460   for( int i=-margin; i<=margin; ++i ) {
461     int aofs = i < 0 ? 0 : i*stride;
462     int bofs = i < 0 ? -i*stride : 0;
463     uint8_t *ap = a + aofs, *bp = b + bofs;
464     int ierr = 0; int n = sz - abs(i);
465     for( int j=n; --j>=0; ap+=stride,bp+=stride ) ierr += abs(*ap - *bp);
466     double err = (double)ierr / n;
467     if( err < best ) { best = err;  ii = i; }
468   }
469   dev = best;
470   ofs = ii;
471 }
472
473 int64_t MediaDb::
474 cmpr(uint8_t *ap, uint8_t *bp, int sz)
475 {
476   int64_t v = 0;
477   for( int i=sz; --i>=0; ++ap,++bp ) v += abs(*ap-*bp);
478   return v;
479 }
480
481 int64_t MediaDb::
482 diff(uint8_t *a, uint8_t *b, int w, int h, int dx, int dy, int bias)
483 {
484   int axofs = dx < 0 ? 0 : dx;
485   int ayofs = w * (dy < 0 ? 0 : dy);
486   int aofs = ayofs + axofs;
487   int bxofs = dx < 0 ? -dx : 0;
488   int byofs = w * (dy < 0 ? -dy : 0);
489   int bofs = byofs + bxofs;
490   uint8_t *ap = a + aofs, *bp = b + bofs;
491   int ierr = 0, ww = w-abs(dx), hh = h-abs(dy);
492   for( int y=hh; --y>=0; ap+=w, bp+=w ) {
493     a = ap;  b = bp;
494     for( int x=ww; --x>=0; ++a, ++b ) { ierr += abs(*a-bias - *b); }
495   }
496   return ierr;
497 }
498
499 void MediaDb::
500 fit(int *dat, int n, double &a, double &b)
501 {
502         double st2 = 0, sb = 0;
503         int64_t sy = 0;
504         for( int i=0; i<n; ++i ) sy += dat[i];
505         double mx = (n-1)/2., my = (double)sy / n;
506         for( int i=0; i<n; ++i ) {
507                 double t = i - mx;
508                 st2 += t * t;
509                 sb += t * dat[i];
510         }
511         b = sb / st2;
512         a = my - mx*b;
513 }
514
515 void MediaDb::
516 eq(uint8_t *sp, uint8_t *dp, int len)
517 {
518 #if 0
519         int hist[256], wts[256], map[256];
520         for( int i=0; i<256; ++i ) hist[i] = 0;
521         uint8_t *bp = sp;
522         for( int i=len; --i>=0; ++bp ) ++hist[*bp];
523         int t = 0;
524         for( int i=0; i<256; ++i ) { t += hist[i];  wts[i] = t; }
525         int lmn = len/20, lmx = len-lmn;
526         int mn =   0;  while( mn < 256 && wts[mn] < lmn ) ++mn;
527         int mx = 255;  while( mx > mn && wts[mx] > lmx ) --mx;
528         double a, b;
529         fit(&wts[mn], mx-mn, a, b);
530         double r = 256./len;
531         double a1 = (a - b*mn) * r, b1 = b * r;
532         for( int i=0 ; i<256;  ++i ) map[i] = clip(a1 + i*b1, 0, 255);
533         for( int i=len; --i>=0; ++sp,++dp ) *dp = map[*sp];
534 #else
535         if( sp != dp ) memcpy(dp,sp,len);
536 #endif
537 }
538
539 // record constructors
540 int MediaDb::
541 new_frame(int clip_id, uint8_t *dat, int no, int group, double offset)
542 {
543 //printf("add %d at %f\n",no,tm);
544         int fid, ret = get_media_key(dat, fid, MEDIA_FRAME_DIST, MEDIA_FRAME_ERRLMT);
545         if( ret < 0 ) return -1;
546         if( ret > 0 ) {
547                 db->video_frame.Allocate();
548                 uint8_t *fp = db->video_frame._Frame_data(SFRM_SZ);
549                 eq(dat, fp, SFRM_SZ);
550                 double mn = mean(dat, SFRM_SZ);
551                 db->video_frame.Frame_mean(mn);
552                 double sd = std_dev(dat, mn, SFRM_SZ);
553                 db->video_frame.Frame_std_dev(sd);
554                 double cx, cy;  centroid(dat, SWIDTH, SHEIGHT, cx, cy);
555                 db->video_frame.Frame_cx(cx);
556                 db->video_frame.Frame_cy(cy);
557                 double moment = cx + cy;
558                 db->video_frame.Frame_moment(moment);
559                 db->video_frame.Construct();
560                 fid = db->video_frame.id();
561         }
562         db->timeline.Allocate();
563         db->timeline.Clip_id(clip_id);
564         db->timeline.Sequence_no(no);
565         db->timeline.Frame_id(fid);
566         db->timeline.Group(group);
567         db->timeline.Time_offset(offset);
568         db->timeline.Construct();
569         return 0;
570 }
571
572 int MediaDb::
573 new_clip_set(const char *title, const char *asset_path, double position,
574         double framerate, int frames, int prefix_size, int suffix_size,
575         int64_t creation_time, int64_t system_time)
576 {
577         db->clip_set.Allocate();
578         db->clip_set.Title(title);
579         db->clip_set.Asset_path(asset_path);
580         db->clip_set.Position(position);
581         db->clip_set.Framerate(framerate);
582         db->clip_set.Frames(frames);
583         db->clip_set.Prefix_size(prefix_size);
584         db->clip_set.Suffix_size(suffix_size);
585         db->clip_set._Weights(frames*sizeof(double));
586         db->clip_set.Creation_time(creation_time);
587         db->clip_set.System_time(system_time);
588         db->clip_set.Construct();
589
590         return new_clip_view(db->clip_set.id(), creation_time);
591 }
592
593 int MediaDb::
594 new_clip_view(int clip_id, int64_t access_time)
595 {
596         db->clip_views.Allocate();
597         db->clip_views.Access_clip_id(clip_id);
598         db->clip_views.Access_time(access_time);
599         db->clip_views.Access_count(1);
600         db->clip_views.Construct();
601         return 0;
602 }
603
604 int MediaDb::
605 access_clip(int clip_id, int64_t access_time)
606 {
607         if( Clip_viewsLoc::ikey_Clip_access(db->clip_views,clip_id).Find() ) return 1;
608         db->clip_views.Destruct();
609         if( !access_time ) { time_t at;  ::time(&at);  access_time = (int64_t)at; }
610         db->clip_views.Access_time(access_time);
611         int access_count = db->clip_views.Access_count();
612         db->clip_views.Access_count(access_count+1);
613         db->clip_views.Construct();
614         return 0;
615 }
616
617 int MediaDb::
618 del_clip_set(int clip_id)
619 {
620         if( db->clip_set.FindId(clip_id) ) return 1;
621         // delete clip_set
622         db->clip_set.Destruct();
623         db->clip_set.Deallocate();
624         // delete clip_views
625         if( Clip_viewsLoc::ikey_Clip_access(db->clip_views,clip_id).Find() ) return 1;
626         db->clip_views.Destruct();
627         db->clip_views.Deallocate();
628         // delete timeline
629         while( !TimelineLoc::ikey_Sequences(db->timeline,clip_id,0).Locate() ) {
630                 if( clip_id != (int)db->timeline.Clip_id() ) break;
631                 int frame_id = db->timeline.Frame_id();
632                 db->timeline.Destruct();
633                 db->timeline.Deallocate();
634                 // check for more timeline refs
635                 if( !TimelineLoc::ikey_Timelines(db->timeline, frame_id).Locate() &&
636                         frame_id == (int)db->timeline.Frame_id() ) continue;
637                 if( db->video_frame.FindId(frame_id) ) continue;
638                 // delete frame
639                 db->video_frame.Destruct();
640                 db->video_frame.Deallocate();
641         }
642         return 0;
643 }
644
645
646 // db file operations
647 int MediaDb::
648 newDb()
649 {
650         if( opened > 0 || db->create(MEDIA_DB) ) {
651                 printf("MediaDb::newDb failed\n");
652                 return opened = -1;
653         }
654         return opened = 0;
655 }
656
657 int MediaDb::
658 openDb(int rw)
659 {
660         if( opened > 0 ) return 0;
661         if( db->access(MEDIA_DB, MEDIA_SHM_KEY, rw) ) {
662                 printf("MediaDb::openDb failed\n");
663                 return opened = -1;
664         }
665         opened = 1;
666         return 0;
667 }
668
669 int MediaDb::
670 resetDb(int rw)
671 {
672         int result = 0;
673         if( access(MEDIA_DB, F_OK) ) result = newDb();
674         if( !result ) result = openDb(rw);
675         return result;
676 }
677
678 void MediaDb::
679 closeDb()
680 {
681         if( opened > 0 ) { detachDb();  db->close(); }
682         opened = 0;
683 }
684
685 void MediaDb::
686 commitDb()
687 {
688         if( opened > 0 ) db->commit();
689 }
690
691 void MediaDb::
692 undoDb()
693 {
694         if( opened > 0 ) db->undo();
695 }
696
697 int MediaDb::
698 attachDb(int rw)
699 {
700         return opened > 0 ? db->attach(rw) : -1;
701 }
702
703 int MediaDb::
704 detachDb()
705 {
706         return opened > 0 ? db->detach() : -1;
707 }
708
709
710 int MediaDb::
711 get_timelines(int frame_id)
712 {
713         return TimelineLoc::ikey_Timelines(db->timeline, frame_id).Locate();
714 }
715
716 int MediaDb::
717 next_timelines()
718 {
719         return TimelineLoc::rkey_Timelines(db->timeline).Next();
720 }
721
722 int MediaDb::
723 get_sequences(int clip_id, int seq_no)
724 {
725         int ret = TimelineLoc::ikey_Sequences(db->timeline,clip_id,seq_no).Locate();
726         if( !ret && clip_id != (int)db->timeline.Clip_id() ) ret = 1;
727         return ret;
728 }
729
730 int MediaDb::
731 next_sequences()
732 {
733         return TimelineLoc::rkey_Sequences(db->timeline).Next();
734 }
735
736 // frame accessors
737 int MediaDb::
738 get_image(int id, uint8_t *dat, int &w, int &h)
739 {
740         int result = 1;
741         if( !db->video_frame.FindId(id) ) {
742                 memcpy(dat, db->video_frame.Frame_data(), SFRM_SZ);
743                 w = SWIDTH;  h = SHEIGHT;
744                 result = 0;
745         }
746         return result;
747 }
748
749 int MediaDb::
750 get_frame_key(uint8_t *dat, int &fid,
751                 Clips *clips, double pos, int mask)
752 {
753         return get_media_key(dat, fid,
754                         MEDIA_SEARCH_DIST, MEDIA_SEARCH_ERRLMT,
755                         clips, pos, mask);
756 }
757
758 int MediaDb::
759 get_media_key(uint8_t *dat, int &fid, int dist, double errlmt,
760                 Clips *clips, double pos, int mask)
761 {
762         fmean = mean(dat, SFRM_SZ);
763         if( fmean < 17 ) return -1; // black, forbidden
764         if( fmean > 239 ) return -1; // white, forbidden
765         distance = dist;
766         pixlmt = SFRM_SZ*errlmt;
767         position = pos;
768         group_mask = mask;
769         fsd = std_dev(dat, fmean, SFRM_SZ);
770         centroid(dat, SWIDTH, SHEIGHT, fcx, fcy);
771         fmoment = fcx + fcy;
772         eq(dat, frm, SFRM_SZ);
773         if( clips ) ++clips->cycle;
774         lid = nid = -1;
775         lerr = LONG_MAX;
776         int result = 1;
777
778         if( !Video_frameLoc::ikey_Frame_center(db->video_frame, fmoment).Locate() ) {
779                 Video_frameLoc prev(db->video_frame), next(db->video_frame);
780                 Video_frameLoc::rkey_Frame_center prev_ctr(prev), next_ctr(next);
781                 if( !get_key(clips, prev_ctr, next_ctr) ) result = 0;
782         }
783         if( !Video_frameLoc::ikey_Frame_weight(db->video_frame, fmean).Locate() ) {
784                 Video_frameLoc prev(db->video_frame), next(db->video_frame);
785                 Video_frameLoc::rkey_Frame_weight prev_wt(prev), next_wt(next);
786                 if( !get_key(clips, prev_wt, next_wt) ) result = 0;
787         }
788
789         fid = lid;
790         return result;
791 }
792
793 int MediaDb::
794 get_key(Clips *clips, Db::rKey &prev_rkey, Db::rKey &next_rkey)
795 {
796         key_compare(clips, next_rkey.loc);
797         // search outward from search target for frame with least error
798         Db::pgRef next_loc;  next_rkey.NextLoc(next_loc);
799
800         for( int i=1; i<=distance; ++i ) {
801                 if( !prev_rkey.Locate(Db::keyLT) )
802                         key_compare(clips,prev_rkey.loc);
803                 if( !next_rkey.Next(next_loc) )
804                         key_compare(clips,next_rkey.loc);
805         }
806
807         return lerr < pixlmt ? 0 : 1;
808 }
809
810 int64_t MediaDb::
811 key_compare(Clips *clips, Db::ObjectLoc &loc)
812 {
813         int id = loc.id();
814         if( nid == id ) return 1;
815         nid = id;
816         Video_frameLoc &frame = *(Video_frameLoc*)&loc;
817         double dm = frame.Frame_mean()-fmean;
818         if( fabs(dm) > MEDIA_MEAN_ERRLMT ) return 1;
819         double ds = frame.Frame_std_dev()-fsd;
820         if( fabs(ds) > MEDIA_STDDEV_ERRLMT ) return 1;
821         double dx = frame.Frame_cx()-fcx;
822         if( fabs(dx) > MEDIA_XCENTER_ERRLMT ) return 1;
823         double dy = frame.Frame_cy()-fcy;
824         if( fabs(dy) > MEDIA_YCENTER_ERRLMT ) return 1;
825         uint8_t *dat = frame._Frame_data();
826         //int64_t err = cmpr(frm, dat, SFRM_SZ);
827         int64_t err = diff(frm, dat, SWIDTH, SHEIGHT, lround(dx), lround(dy), lround(dm));
828         if( lerr > err ) { lerr = err;  lid = id; }
829         if( clips && err < pixlmt ) add_timelines(clips, id, err);
830         return 0;
831 }
832
833 int MediaDb::
834 add_timelines(Clips *clips, int fid, double err)
835 {
836         // found frame, find timelines
837         if( get_timelines(fid) ) {
838                 printf(_(" find timeline frame_id(%d) failed\n"), fid);
839                 return 1;
840         }
841
842         // process Timelines which contain Frame_id
843         int cid = -1;
844         for( int ret=0; !ret && timeline_frame_id()==fid; ret=next_timelines() ) {
845                 int tid = timeline_clip_id();
846                 if( tid != cid && clip_id(cid=tid) ) break;
847                 double start_time = position - timeline_offset();
848                 if( start_time < 0 ) continue;
849                 int group = timeline_group();
850                 if( (group & group_mask) == 0 ) continue;
851                 double length = clip_length();
852                 double end_time = start_time + length;
853 //printf("clip=%d, pos=%f, time=%f-%f, %s\n",
854 //  cid, position, start_time, end_time, clip_title());
855                 clips->check(cid, start_time, end_time, group, err);
856         }
857
858         return 0;
859 }
860