mwallp - simple wallpaper setting tool using MPlayer codebase

git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@6458 b3059339-0415-0410-9bf9-f77b7e298cf2

TOOLS/mwallp/README

@@ -0,0 +1,23 @@
+mwallp - mplayer's wallpaper setting utility
+======
+
+Usage: mwallp file1.jpg [file2.jpg file3.jpg ...]
+~~~~~~
+
+About:
+~~~~~~
+MWallp is a simple tool to set .jpg images as background/wallpaper on the
+desktop. It scales (bicubic) and convert the given jpg image to desktop
+size/bpp and set as background of Root window.
+
+If more than 1 filenames given, it randomly selects one, so running something
+like 'mwallp ~/.wallpapers/*.jpg' from cron will randomly changes wallpaper.
+
+Why?
+~~~~
+I've tried several programs, and as most of them used Imlib, their quality
+sucks (Imlib uses neares-neighbour scaling...).
+So I've decided to put together something very simple but efficient built
+using the MPlayer codebase.
+
+A'rpi

TOOLS/mwallp/compile.sh

@@ -0,0 +1,5 @@
+
+gcc -g mwallp.c jpeg.c ../../libvo/aclib.o ../../libmpcodecs/img_format.o \
+    ../../cpudetect.o ../../mp_msg.o ../../postproc/libpostproc.a \
+    -I../../libmpcodecs -I../.. -I../../postproc \
+    -L/usr/X11/lib -lX11 -ljpeg -o mwallp

TOOLS/mwallp/jpeg.c

@@ -0,0 +1,147 @@
+// based on vd_ijpg.c by Pontscho
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <jpeglib.h>
+#define UINT16 IJPG_UINT16
+#define INT16 IJPG_INT16
+
+#include <setjmp.h>
+
+#include <inttypes.h>
+
+#include "img_format.h"
+
+#include "swscale.h"
+#include "rgb2rgb.h"
+
+static SwsContext *swsContext=NULL;
+
+typedef struct
+{
+ struct          jpeg_source_mgr pub;
+ unsigned char * inbuf;
+ int             bufsize;
+} my_source_mgr;
+
+typedef my_source_mgr * my_src_ptr;
+
+METHODDEF(void) init_source (j_decompress_ptr cinfo)
+{
+}
+
+METHODDEF(boolean) fill_input_buffer (j_decompress_ptr cinfo)
+{
+ my_src_ptr src = (my_src_ptr) cinfo->src;                                                         
+ size_t nbytes;                                                                                    
+ src->pub.next_input_byte = src->inbuf;
+ src->pub.bytes_in_buffer = src->bufsize;
+ return TRUE;
+}
+                                                                                                        
+METHODDEF(void) skip_input_data (j_decompress_ptr cinfo, long num_bytes)                           
+{                                                                                                  
+ my_src_ptr src = (my_src_ptr) cinfo->src;                                                        
+
+ if (num_bytes > 0)
+  {
+   while (num_bytes > (long) src->pub.bytes_in_buffer)
+    {
+     num_bytes -= (long) src->pub.bytes_in_buffer;
+     (void) fill_input_buffer(cinfo);
+    }
+   src->pub.next_input_byte += (size_t) num_bytes;
+   src->pub.bytes_in_buffer -= (size_t) num_bytes;
+  }
+}
+
+METHODDEF(void) term_source (j_decompress_ptr cinfo) { }                                           
+
+GLOBAL(void) jpeg_buf_src ( j_decompress_ptr cinfo, char * inbuf,int bufsize )
+{
+ my_src_ptr src;
+ if (cinfo->src == NULL) cinfo->src=malloc( sizeof( my_source_mgr ) );
+ src = (my_src_ptr) cinfo->src;
+ src->pub.init_source = init_source;
+ src->pub.fill_input_buffer = fill_input_buffer;
+ src->pub.skip_input_data = skip_input_data;
+ src->pub.resync_to_restart = jpeg_resync_to_restart;
+ src->pub.term_source = term_source;
+ src->inbuf = inbuf;
+ src->bufsize=bufsize;
+ src->pub.bytes_in_buffer = 0;
+ src->pub.next_input_byte = NULL;
+}
+
+struct my_error_mgr
+{
+ struct jpeg_error_mgr pub;
+ jmp_buf setjmp_buffer;
+};
+
+typedef struct my_error_mgr * my_error_ptr;
+
+METHODDEF(void) my_error_exit (j_common_ptr cinfo)
+{
+ my_error_ptr myerr=(my_error_ptr) cinfo->err;
+ (*cinfo->err->output_message) (cinfo);
+ longjmp(myerr->setjmp_buffer, 1);
+}
+
+static struct     jpeg_decompress_struct cinfo;
+static struct     my_error_mgr jerr;
+
+// decode a frame
+int decode_jpeg(void* data,int len,char* dbuffer,int dwidth,int dheight, int dstride,int dbpp){
+ int	      width,height,depth,i;
+ int        row_stride;
+ unsigned char*	img=NULL;
+ int in_fmt=0;
+
+ if ( len <= 0 ) return 0; // skipped frame
+
+ cinfo.err=jpeg_std_error( &jerr.pub );
+ jerr.pub.error_exit=my_error_exit;
+ if( setjmp( jerr.setjmp_buffer ) )
+  {
+   return 0;
+  }
+  
+ jpeg_create_decompress( &cinfo );
+ jpeg_buf_src( &cinfo,data,len );
+ jpeg_read_header( &cinfo,TRUE );
+ width=cinfo.image_width;
+ height=cinfo.image_height;
+ jpeg_start_decompress( &cinfo );
+ depth=cinfo.output_components * 8;
+
+ switch( depth ) {
+   case 8: in_fmt=IMGFMT_Y8;break;
+   case 24: in_fmt=IMGFMT_RGB|24;break;
+   default: return 0;
+ }
+
+ row_stride=cinfo.output_width * cinfo.output_components;
+ img=malloc(row_stride * (height+1));
+
+ for ( i=0;i < height;i++ ){
+//    char* row=dbuffer+i*dstride;
+    char* row=img+row_stride*i;
+    jpeg_read_scanlines( &cinfo,(JSAMPLE**)&row,1 );
+ }
+ 
+ jpeg_finish_decompress(&cinfo);
+ jpeg_destroy_decompress(&cinfo);
+
+ swsContext= getSwsContextFromCmdLine(width,height, in_fmt, 
+    				      dwidth,dheight, IMGFMT_BGR|dbpp);
+
+ swsContext->swScale(swsContext,&img,&row_stride,0,height,&dbuffer, &dstride);
+ 
+ freeSwsContext(swsContext);
+
+ free(img);
+
+ return 1;
+}

TOOLS/mwallp/mwallp.c

@@ -0,0 +1,115 @@
+// based on x11_common.c/vo_x11.c from libvo
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include <X11/Xmd.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+
+#include "cpudetect.h"
+
+char* mDisplayName=NULL;
+Display* mDisplay=NULL;
+Window   mRootWin=None;
+int mScreen=0;
+XImage  * mXImage = NULL;
+GC         vo_gc = NULL;
+Pixmap mPixmap=0;
+
+int vo_depthonscreen=0;
+int vo_screenwidth=0;
+int vo_screenheight=0;
+
+int verbose=0;
+int namecnt=0;
+
+int main(int argc,char* argv[]){
+ unsigned int mask;
+ int bpp,depth;
+
+ mp_msg_init();
+ mp_msg_set_level(5);
+
+ GetCpuCaps(&gCpuCaps);
+ 
+ mDisplayName = XDisplayName(mDisplayName);
+ mDisplay=XOpenDisplay(mDisplayName);
+ if ( !mDisplay )
+  {
+   printf("vo: couldn't open the X11 display (%s)!\n",mDisplayName );
+   return 0;
+  }
+ mScreen=DefaultScreen( mDisplay );     // Screen ID.
+ mRootWin=RootWindow( mDisplay,mScreen );// Root window ID.
+
+ vo_screenwidth=DisplayWidth( mDisplay,mScreen );
+ vo_screenheight=DisplayHeight( mDisplay,mScreen );
+
+ // get color depth (from root window, or the best visual):
+ {  XWindowAttributes attribs;
+    XGetWindowAttributes(mDisplay, mRootWin, &attribs);
+    depth=vo_depthonscreen=attribs.depth;
+ }
+ mXImage=XGetImage( mDisplay,mRootWin,0,0,vo_screenwidth,vo_screenheight,AllPlanes,ZPixmap );
+
+ bpp=mXImage->bits_per_pixel;
+ if((vo_depthonscreen+7)/8 != (bpp+7)/8) vo_depthonscreen=bpp; // by A'rpi
+ mask=mXImage->red_mask|mXImage->green_mask|mXImage->blue_mask;
+
+ if(((vo_depthonscreen+7)/8)==2){
+   if(mask==0x7FFF) vo_depthonscreen=15; else
+   if(mask==0xFFFF) vo_depthonscreen=16;
+ }
+ 
+ printf("X11 running at %d x %d, %d bpp \n",vo_screenwidth,vo_screenheight,vo_depthonscreen);
+
+ mPixmap=XCreatePixmap(mDisplay,mRootWin,vo_screenwidth,vo_screenheight,depth);
+
+ {  XGCValues xgcv;
+    vo_gc=XCreateGC( mDisplay,mRootWin,0L,&xgcv );
+ }
+
+ if(argc<2){ printf("no filenames!\n");return;}
+
+ srand(time(NULL));
+
+while(1){
+ FILE *f;
+ char* data;
+ int len;
+ int ret;
+ 
+ namecnt=1+(long long)rand()*(argc-1)/RAND_MAX;
+ //++namecnt; if(namecnt>=argc) namecnt=1;
+ if(namecnt<1 || namecnt>=argc) continue; // ???
+ 
+ f=fopen(argv[namecnt],"rb");if(!f) continue;
+ fseek(f,0,SEEK_END); len=ftell(f); fseek(f,0,SEEK_SET);
+ data=malloc(len);
+ len=fread(data,1,len,f);
+ fclose(f);
+
+ ret=decode_jpeg(data,len,mXImage->data,vo_screenwidth,vo_screenheight,
+   ((vo_depthonscreen+7)/8)*vo_screenwidth,vo_depthonscreen);
+
+ free(data);
+ 
+ if(!ret) continue; // failed to load
+
+ XPutImage( mDisplay,mPixmap,vo_gc,mXImage,
+               0,0, 0,0, vo_screenwidth,vo_screenheight);
+ XSetWindowBackgroundPixmap(mDisplay,mRootWin,mPixmap);
+ XClearWindow(mDisplay,mRootWin);
+ XSync(mDisplay, True);
+ 
+ break; // DONE!
+}
+
+}