add missing GPL information in guicast program files
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / ydiff.C
1 #include <stdio.h>
2 #include <stdint.h>
3 #include <stdlib.h>
4 #include <math.h>
5 #include <pthread.h>
6 #include <signal.h>
7 #include <string.h>
8 #include <unistd.h>
9 #include <sys/stat.h>
10 #include <sys/time.h>
11 #include <sys/ipc.h>
12 #include <sys/shm.h>
13
14 #include <X11/Xatom.h>
15 #include <X11/Xlib.h>
16 #include <X11/Xutil.h>
17 #include <X11/extensions/XShm.h>
18
19 extern "C" {
20 #include "libavfilter/buffersrc.h"
21 #include "libavfilter/buffersink.h"
22 #include "libavformat/avformat.h"
23 #include "libavformat/avio.h"
24 #include "libavcodec/avcodec.h"
25 #include "libavfilter/avfilter.h"
26 #include "libavutil/avutil.h"
27 #include "libavutil/imgutils.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/pixdesc.h"
30 #include "libswresample/swresample.h"
31 #include "libswscale/swscale.h"
32 }
33
34 #ifdef FFMPEG3
35 #define url filename
36 #else
37 #define av_register_all(s)
38 #define avfilter_register_all(s)
39 #endif
40
41 int done = 0;
42 int64_t tm = 0, tn = 0;
43
44 void sigint(int n)
45 {
46   done = 1;
47 }
48
49 class gg_window
50 {
51 public:
52   gg_window(Display *display, int x, int y, int w, int h);
53   ~gg_window();
54   Display *display;
55   Window win;
56   GC gc;
57   int x, y, w, h;
58   void show();
59   void hide();
60 };
61
62 gg_window::gg_window(Display *display, int x, int y, int w, int h)
63 {
64   this->display = display;
65   this->x = x;  this->y = y;
66   this->w = w;  this->h = h;
67
68   Window root = DefaultRootWindow(display);
69   Screen *screen = DefaultScreenOfDisplay(display);
70   Visual *visual = DefaultVisualOfScreen(screen);
71   int depth = DefaultDepthOfScreen(screen);
72   int border = 0;
73   unsigned long gcmask = GCGraphicsExposures;
74   XGCValues gcvalues;
75   gcvalues.graphics_exposures = 0;
76   gc = XCreateGC(display, root, gcmask, &gcvalues);
77
78   XSetWindowAttributes attributes;
79   attributes.background_pixel = BlackPixel(display, DefaultScreen(display));
80   attributes.border_pixel = WhitePixel(display, DefaultScreen(display));
81   attributes.event_mask =
82     EnterWindowMask | LeaveWindowMask |
83     ButtonPressMask | ButtonReleaseMask |
84     PointerMotionMask | FocusChangeMask;
85   int valueMask = CWBackPixel | CWBorderPixel | CWEventMask;
86   this->win = XCreateWindow(display, root, x, y, w, h, border, depth,
87       InputOutput, visual, valueMask, &attributes);
88 }
89
90 gg_window::~gg_window()
91 {
92   XFreeGC(display, gc);
93   XDestroyWindow(display, win);
94 }
95
96 void gg_window::show()
97 {
98   XMapWindow(display,win);
99   XFlush(display);
100 }
101 void gg_window::hide()
102 {
103   XUnmapWindow(display,win);
104   XFlush(display);
105 }
106
107 class gg_ximage
108 {
109 public:
110   Display *display;
111   XShmSegmentInfo shm_info;
112   XImage *ximage;
113   int w, h;
114   unsigned char *data;
115   int shm, sz;
116   uint32_t lsb[3];
117   gg_ximage(Display *display, int w, int h, int shm);
118   ~gg_ximage();
119
120   void put_image(gg_window &gw);
121 };
122
123 gg_ximage::gg_ximage(Display *display, int w, int h, int shm)
124 {
125   this->display = display;
126   this->w = w;  this->h = h;
127   this->shm = shm;
128
129   ximage = 0;  sz = 0;  data = 0;
130   Screen *screen = DefaultScreenOfDisplay(display);
131   Visual *visual = DefaultVisualOfScreen(screen);
132   int depth = DefaultDepthOfScreen(screen);
133
134   if( shm ) {
135     ximage = XShmCreateImage(display, visual, depth, ZPixmap, (char*)NULL, &shm_info, w, h);
136 // Create shared memory
137     sz = h * ximage->bytes_per_line;
138     shm_info.shmid = shmget(IPC_PRIVATE, sz + 8, IPC_CREAT | 0777);
139     if(shm_info.shmid < 0) perror("shmget");
140     data = (unsigned char *)shmat(shm_info.shmid, NULL, 0);
141 // This causes it to automatically delete when the program exits.
142     shmctl(shm_info.shmid, IPC_RMID, 0);
143     ximage->data = shm_info.shmaddr = (char*)data;
144     shm_info.readOnly = 0;
145 // Get the real parameters
146     if(!XShmAttach(display, &shm_info)) perror("XShmAttach");
147   }
148   else {
149       ximage = XCreateImage(display, visual, depth, ZPixmap, 0, (char*)data, w, h, 8, 0);
150       sz = h * ximage->bytes_per_line;
151       data = new unsigned char[sz+8];
152   }
153   memset(data, 0, sz);
154   ximage->data = (char*) data;
155   lsb[0] = ximage->red_mask & ~(ximage->red_mask<<1);
156   lsb[1] = ximage->green_mask & ~(ximage->green_mask<<1);
157   lsb[2] = ximage->blue_mask & ~(ximage->blue_mask<<1);
158 }
159
160 gg_ximage::~gg_ximage()
161 {
162   if( shm ) {
163     data = 0;
164     ximage->data = 0;
165     XDestroyImage(ximage);
166     XShmDetach(display, &shm_info);
167     XFlush(display);
168     shmdt(shm_info.shmaddr);
169   }
170   else {
171     delete [] data;
172     data = 0;
173     ximage->data = 0;
174     XDestroyImage(ximage);
175   }
176 }
177
178 void gg_ximage::put_image(gg_window &gw)
179 {
180   Display *display = gw.display;
181   Window win = gw.win;
182   GC gc = gw.gc;
183   if( shm )
184     XShmPutImage(display, win, gc, ximage, 0,0, 0,0,w,h, 0);
185   else
186     XPutImage(display, win, gc, ximage, 0,0, 0,0,w,h); 
187   XFlush(display);
188 }
189
190 class gg_thread
191 {
192 public:
193   pthread_t tid;
194   gg_window &gw;
195   gg_ximage *imgs[2], *img;
196   int active, done;
197   gg_thread(gg_window &gw, int shm) ;
198   ~gg_thread();
199
200   static void *entry(void *t);
201   void start();
202   void *run();
203   void join();
204   void post(gg_ximage *ip);
205   gg_ximage *next_img();
206
207   pthread_mutex_t draw;
208   void draw_lock() { pthread_mutex_lock(&draw); }
209   void draw_unlock() { pthread_mutex_unlock(&draw); }
210 };
211
212 gg_thread::gg_thread(gg_window &gw, int shm)
213  : gw(gw)
214 {
215   imgs[0] = new gg_ximage(gw.display, gw.w, gw.h, shm);
216   imgs[1] = new gg_ximage(gw.display, gw.w, gw.h, shm);
217   done = -1;
218   img = 0;  active = 0;
219   pthread_mutex_init(&draw, 0);
220 }
221
222 gg_thread::~gg_thread()
223 {
224   delete imgs[0];
225   delete imgs[1];
226   pthread_mutex_destroy(&draw);
227 }
228
229 void *gg_thread::entry(void *t)
230 {
231   return ((gg_thread*)t)->run();
232 }
233
234 void gg_thread::start()
235 {
236   pthread_attr_t attr;
237   pthread_attr_init(&attr);
238   pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
239   done = 0;
240   pthread_create(&tid, &attr, &entry, this);
241   pthread_attr_destroy(&attr);
242 }
243 void gg_thread::join()
244 {
245   done = 1;
246   pthread_join(tid, 0);
247 }
248
249 void *gg_thread::run()
250 {
251   while( !done ) {
252     if( XPending(gw.display) ) {
253       XEvent xev;
254       XNextEvent(gw.display, &xev);
255       switch( xev.type ) {
256       case KeyPress:
257       case KeyRelease:
258       case ButtonPress:
259       case Expose:
260         break;
261       }
262       continue;
263     }
264
265     if( !img ) { usleep(10000);  continue; }
266     img->put_image(gw);
267     img = 0;
268     draw_unlock();
269   }
270   return (void*)0;
271 }
272
273 gg_ximage *gg_thread::next_img()
274 {
275   gg_ximage *ip = imgs[active];
276   active ^= 1;
277   return ip;
278 }
279
280 void gg_thread::post(gg_ximage *ip)
281 {
282   this->img = ip;
283 }
284
285
286 class ffcmpr {
287 public:
288   ffcmpr();
289   ~ffcmpr();
290   AVPacket ipkt;
291   AVFormatContext *fmt_ctx;
292   AVFrame *ipic;
293   AVStream *st;
294   AVCodecContext *ctx;
295   AVPixelFormat pix_fmt;
296   double frame_rate;
297   int width, height;
298   int need_packet, eof;
299   int open_decoder(const char *filename, int vid_no);
300   void close_decoder();
301   AVFrame *read_frame();
302 };
303
304 ffcmpr::ffcmpr()
305 {
306   av_init_packet(&this->ipkt);
307   this->fmt_ctx = 0;
308   this->ipic = 0;
309   this->st = 0;
310   this->ctx = 0 ;
311   this->frame_rate = 0;
312   this->need_packet = 0;
313   this->eof = 0;
314   this->pix_fmt = AV_PIX_FMT_NONE;
315   width = height = 0;
316 }
317
318 void ffcmpr::close_decoder()
319 {
320   av_packet_unref(&ipkt);
321   if( !fmt_ctx ) return;
322   if( ctx ) avcodec_free_context(&ctx);
323   avformat_close_input(&fmt_ctx);
324   av_frame_free(&ipic);
325 }
326
327 ffcmpr::~ffcmpr()
328 {
329   close_decoder();
330 }
331
332 int ffcmpr::open_decoder(const char *filename, int vid_no)
333 {
334   struct stat fst;
335   if( stat(filename, &fst) ) return 1;
336   fmt_ctx = 0;
337   AVDictionary *fopts = 0;
338   av_register_all();
339   av_dict_set(&fopts, "formatprobesize", "5000000", 0);
340   av_dict_set(&fopts, "scan_all_pmts", "1", 0);
341   av_dict_set(&fopts, "threads", "auto", 0);
342   int ret = avformat_open_input(&fmt_ctx, filename, NULL, &fopts);
343   av_dict_free(&fopts);
344   if( ret < 0 ) {
345     fprintf(stderr,"file open failed: %s\n", filename);
346     return ret;
347   }
348   ret = avformat_find_stream_info(fmt_ctx, NULL);
349   if( ret < 0 ) {
350     fprintf(stderr,"file probe failed: %s\n", filename);
351     return ret;
352   }
353
354   this->st = 0;
355   for( int i=0; !this->st && ret>=0 && i<(int)fmt_ctx->nb_streams; ++i ) {
356     AVStream *fst = fmt_ctx->streams[i];
357     AVMediaType type = fst->codecpar->codec_type;
358     if( type != AVMEDIA_TYPE_VIDEO ) continue;
359     if( --vid_no < 0 ) this->st = fst;
360   }
361
362   AVCodecID codec_id = st->codecpar->codec_id;
363   AVDictionary *copts = 0;
364   //av_dict_copy(&copts, opts, 0);
365   AVCodec *decoder = avcodec_find_decoder(codec_id);
366   ctx = avcodec_alloc_context3(decoder);
367   avcodec_parameters_to_context(ctx, st->codecpar);
368   if( avcodec_open2(ctx, decoder, &copts) < 0 ) {
369     fprintf(stderr,"codec open failed: %s\n", filename);
370     return -1;
371   }
372   av_dict_free(&copts);
373   ipic = av_frame_alloc();
374   eof = 0;
375   need_packet = 1;
376
377   AVRational framerate = av_guess_frame_rate(fmt_ctx, st, 0);
378   this->frame_rate = !framerate.den ? 0 : (double)framerate.num / framerate.den;
379   this->pix_fmt = (AVPixelFormat)st->codecpar->format;
380   this->width  = st->codecpar->width;
381   this->height = st->codecpar->height;
382   return 0;
383 }
384
385 AVFrame *ffcmpr::read_frame()
386 {
387   av_frame_unref(ipic);
388
389   for( int retrys=1000; --retrys>=0; ) {
390     if( need_packet ) {
391       if( eof ) return 0;
392       AVPacket *pkt = &ipkt;
393       av_packet_unref(pkt);
394       int ret = av_read_frame(fmt_ctx, pkt);
395       if( ret < 0 ) {
396         if( ret != AVERROR_EOF ) return 0;
397         ret = 0;  eof = 1;  pkt = 0;
398       }
399       if( pkt ) {
400         if( pkt->stream_index != st->index ) continue;
401         if( !pkt->data || !pkt->size ) continue;
402       }
403       avcodec_send_packet(ctx, pkt);
404       need_packet = 0;
405     }
406     int ret = avcodec_receive_frame(ctx, ipic);
407     if( ret >= 0 ) return ipic;
408     if( ret != AVERROR(EAGAIN) ) {
409       eof = 1; need_packet = 0;
410       break;
411     }
412     need_packet = 1;
413   }
414   return 0;
415 }
416
417 static inline int get_depth(AVPixelFormat pix_fmt)
418 {
419   int depth = 0;
420   const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
421   if( desc ) {
422     for( int i=desc->nb_components; --i>=0; ) {
423       int bits = desc->comp[i].depth;
424       if( depth < bits ) depth = bits;
425     }
426   }
427   return depth;
428 }
429
430 static int diff_frame(AVFrame *afrm, AVFrame *bfrm,
431     gg_ximage *ximg, int w, int h, int s, int a1)
432 {
433   int n = 0, m = 0;
434   uint8_t *arow = afrm->data[0];
435   uint8_t *brow = bfrm->data[0];
436   uint8_t *frow = ximg->data;
437   int asz = afrm->linesize[0], bsz = afrm->linesize[0];
438   XImage *ximage = ximg->ximage;
439   int fsz = ximage->bytes_per_line;
440   int rsz = w, bpp = (ximage->bits_per_pixel+7)/8;
441   uint32_t *lsb = ximg->lsb;
442
443   for( int y=h; --y>=0; arow+=asz, brow+=bsz, frow+=fsz ) {
444     uint16_t *ap = (uint16_t*)arow + a1;
445     uint16_t *bp = (uint16_t*)brow + a1;
446     uint8_t *fp = frow;
447     for( int x=rsz; --x>=0; ) {
448       uint32_t rgb = 0;  uint8_t *rp = fp;
449       for( int i=0; i<3; ++i ) {
450         int d = *ap++ - *bp++;
451         if( s > 0 ) d >>= s;
452         else if( s < 0 ) d <<= -s;
453         int v = d + 128;
454         if( v > 255 ) v = 255;
455         else if( v < 0 ) v = 0;
456         rgb |= v * lsb[i];
457         m += d;
458         if( d < 0 ) d = -d;
459         n += d;
460       }
461       if( ximage->byte_order == MSBFirst )
462         for( int i=3; --i>=0; ) *rp++ = rgb>>(8*i);
463       else
464         for( int i=0; i<3; ++i ) *rp++ = rgb>>(8*i);
465       ++ap;  ++bp;  fp += bpp;
466     }
467   }
468   int sz = h*rsz;
469   printf("%d %d %d %f", sz, m, n, (double)n/sz);
470   tm += m;  tn += n;
471   return n;
472 }
473
474 int main(int ac, char **av)
475 {
476   setbuf(stdout,NULL);
477   XInitThreads();
478   Display *display = XOpenDisplay(getenv("DISPLAY"));
479   if( !display ) {
480     fprintf(stderr,"Unable to open display\n");
481     exit(1);
482   }
483   if( ac < 3 ) {
484     printf("usage: %s a.fmt b.fmt <frm0> <s>\n"
485         "  a = src media, b = src media, frm0 = a/b skew\n"
486         "  s = shift <0:lt, =0:none(dft), >0:rt\n"
487         "  env var GG_LOG_LEVEL=q/f/e/v/d/<nbr>\n", av[0]);
488     exit(1);
489   }
490   const char *cp = getenv("GG_LOG_LEVEL");
491   if( cp ) {
492     int lvl = -1;
493     switch( *cp ) {
494     case 'q':  lvl = AV_LOG_QUIET;    break;
495     case 'f':  lvl = AV_LOG_FATAL;    break;
496     case 'e':  lvl = AV_LOG_ERROR;    break;
497     case 'v':  lvl = AV_LOG_VERBOSE;  break;
498     case 'd':  lvl = AV_LOG_DEBUG;    break;
499     case '0'...'9': lvl = atoi(cp);   break;
500     }
501     if( lvl >= 0 )
502       av_log_set_level(lvl);
503   }
504
505   ffcmpr a, b;
506   if( a.open_decoder(av[1],0) ) return 1;
507   if( b.open_decoder(av[2],0) ) return 1;
508
509   int64_t err = 0;
510   int frm_no = 0;
511   int frm0 = ac>3 ? atoi(av[3]) : 0;
512   int s = ac>4 ? atoi(av[4]) : 0;
513
514   printf("file a:%s\n", av[1]);
515   printf("  id 0x%06x:", a.ctx->codec_id);
516   const AVCodecDescriptor *adesc = avcodec_descriptor_get(a.ctx->codec_id);
517   printf("  video %s\n", adesc ? adesc->name : " (unkn)");
518   printf(" %dx%d %5.2f", a.width, a.height, a.frame_rate);
519   const char *apix = av_get_pix_fmt_name(a.pix_fmt);
520   int ad = get_depth(a.pix_fmt);
521   printf(" pix %s, depth=%d\n", apix ? apix : "(unkn)", ad);
522
523   printf("file b:%s\n", av[2]);
524   printf("  id 0x%06x:", b.ctx->codec_id);
525   const AVCodecDescriptor *bdesc = avcodec_descriptor_get(b.ctx->codec_id);
526   printf("  video %s\n", bdesc ? bdesc->name : " (unkn)");
527   printf(" %dx%d %5.2f", b.width, b.height, b.frame_rate);
528   const char *bpix = av_get_pix_fmt_name(b.pix_fmt);
529   int bd = get_depth(b.pix_fmt);
530   printf(" pix %s, depth=%d\n", bpix ? bpix : "(unkn)", bd);
531   int d = ad>bd ? ad : bd;
532   s = 16-d + s;
533   int lsb = s, msb = lsb + 7;
534   if( lsb < 0 ) lsb = 0;
535   if( msb > 15 ) msb = 15;
536   printf("shift: %d, msb..lsb: %d..%d of uint16\n", s, msb, lsb);
537
538 //  if( a.ctx->codec_id != b.ctx->codec_id ) { printf("codec mismatch\n"); return 1;}
539   if( a.width != b.width ) { printf("width mismatch\n"); return 1;}
540   if( a.height != b.height ) { printf("height mismatch\n"); return 1;}
541 //  if( a.frame_rate != b.frame_rate ) { printf("framerate mismatch\n"); return 1;}
542 //  if( a.pix_fmt != b.pix_fmt ) { printf("format mismatch\n"); return 1;}
543
544   signal(SIGINT,sigint);
545   const AVPixFmtDescriptor *afmt = av_pix_fmt_desc_get(a.pix_fmt);
546   AVPixelFormat a_pix_fmt = afmt->flags & AV_PIX_FMT_FLAG_RGB ?
547       AV_PIX_FMT_RGBA64LE : AV_PIX_FMT_AYUV64LE ;
548   const AVPixFmtDescriptor *bfmt = av_pix_fmt_desc_get(b.pix_fmt);
549   AVPixelFormat b_pix_fmt = bfmt->flags & AV_PIX_FMT_FLAG_RGB ?
550       AV_PIX_FMT_RGBA64LE : AV_PIX_FMT_AYUV64LE ;
551   if( a_pix_fmt != b_pix_fmt ) {
552     printf(" a/b yuv/rgb mismatched, using a = %s\n", apix);
553     b_pix_fmt = a_pix_fmt;
554   }
555   int a1 = a_pix_fmt == AV_PIX_FMT_AYUV64LE ? 1 : 0; // alpha 1st chan
556
557   struct SwsContext *a_cvt = sws_getCachedContext(0, a.width, a.height, a.pix_fmt,
558                 a.width, a.height, a_pix_fmt, SWS_POINT, 0, 0, 0);
559   struct SwsContext *b_cvt = sws_getCachedContext(0, b.width, b.height, b.pix_fmt,
560                 b.width, b.height, b_pix_fmt, SWS_POINT, 0, 0, 0);
561   if( !a_cvt || !b_cvt ) {
562     printf("sws_getCachedContext() failed\n");
563     exit(1);
564   }
565
566   AVFrame *afrm = av_frame_alloc();
567   av_image_alloc(afrm->data, afrm->linesize,
568      a.width, a.height, a_pix_fmt, 1);
569
570   AVFrame *bfrm = av_frame_alloc();
571   av_image_alloc(bfrm->data, bfrm->linesize,
572      b.width, b.height, b_pix_fmt, 1);
573 { gg_window gw(display, 10,10, a.width,a.height);
574   gw.show();
575   gg_thread thr(gw, 1);
576   thr.start();
577
578   while( frm0 > 0 ) { a.read_frame(); --frm0; }
579   while( frm0 < 0 ) { b.read_frame(); ++frm0; }
580
581   while( !done ) {
582     AVFrame *ap = a.read_frame();
583     if( !ap ) break;
584     AVFrame *bp = b.read_frame();
585     if( !bp ) break;
586     sws_scale(a_cvt, ap->data, ap->linesize, 0, ap->height,
587        afrm->data, afrm->linesize);
588     sws_scale(b_cvt, bp->data, bp->linesize, 0, bp->height,
589        bfrm->data, bfrm->linesize);
590     thr.draw_lock();
591     gg_ximage *fimg = thr.next_img();
592     int ret = diff_frame(afrm, bfrm, fimg, ap->width, ap->height, s, a1);
593     thr.post(fimg);
594     err += ret;  ++frm_no;
595     printf("  %d\n",frm_no);
596   }
597
598   av_freep(&afrm->data);
599   av_frame_free(&afrm);
600   av_freep(&bfrm->data);
601   av_frame_free(&bfrm);
602   
603   b.close_decoder();
604   a.close_decoder();
605
606   thr.join();
607   gw.hide(); }
608   XCloseDisplay(display);
609   printf("\n%jd %jd\n", tm, tn);
610   return 0;
611 }
612