diff options
Diffstat (limited to 'src')
78 files changed, 10311 insertions, 0 deletions
diff --git a/src/Makefile.am b/src/Makefile.am new file mode 100644 index 0000000..a63c3c4 --- /dev/null +++ b/src/Makefile.am @@ -0,0 +1,94 @@ +bin_PROGRAMS = recordmydesktop + +recordmydesktop_SOURCES = \ + rmd.c \ + rmd_cache.c \ + rmd_cache.h \ + rmd_cache_audio.c \ + rmd_cache_audio.h \ + rmd_cache_frame.c \ + rmd_cache_frame.h \ + rmd_capture_sound.c \ + rmd_capture_sound.h \ + rmd_encode_cache.c \ + rmd_encode_cache.h \ + rmd_encode_image_buffer.c \ + rmd_encode_image_buffer.h \ + rmd_encode_sound_buffer.c \ + rmd_encode_sound_buffer.h \ + rmd_error.c \ + rmd_error.h \ + rmd_flush_to_ogg.c \ + rmd_flush_to_ogg.h \ + rmd_frame.c \ + rmd_frame.h \ + rmd_get_frame.c \ + rmd_get_frame.h \ + rmd_getzpixmap.c \ + rmd_getzpixmap.h \ + rmd_init_encoder.c \ + rmd_init_encoder.h \ + rmd_initialize_data.c \ + rmd_initialize_data.h \ + rmd_jack.c \ + rmd_jack.h \ + rmd_load_cache.c \ + rmd_load_cache.h \ + rmd_macro.h \ + rmd_make_dummy_pointer.c \ + rmd_make_dummy_pointer.h \ + rmd_math.c \ + rmd_math.h \ + rmd_opendev.c \ + rmd_opendev.h \ + rmd_parseargs.c \ + rmd_parseargs.h \ + rmd_poll_events.c \ + rmd_poll_events.h \ + rmd_queryextensions.c \ + rmd_queryextensions.h \ + rmd_rectinsert.c \ + rmd_rectinsert.h \ + rmd_register_callbacks.c \ + rmd_register_callbacks.h \ + rmd_rescue.c \ + rmd_rescue.h \ + rmd_setbrwindow.c \ + rmd_setbrwindow.h \ + rmd_shortcuts.c \ + rmd_shortcuts.h \ + rmd_specsfile.c \ + rmd_specsfile.h \ + rmd_threads.c \ + rmd_threads.h \ + rmd_timer.c \ + rmd_timer.h \ + rmd_types.h \ + rmd_update_image.c \ + rmd_update_image.h \ + rmd_wm_check.c \ + rmd_wm_check.h \ + rmd_wm_is_compositing.c \ + rmd_wm_is_compositing.h \ + rmd_yuv_utils.c \ + rmd_yuv_utils.h \ + skeleton.c \ + skeleton.h + +recordmydesktop_CPPFLAGS = -D_THREAD_SAFE -pthread -Wall +recordmydesktop_LDFLAGS = @X_LIBS@ @X_EXTRA_LIBS@ @X_PRE_LIBS@ + + +# RectInsert test +TESTS = test-rectinsert +EXTRA_PROGRAMS = test-rectinsert +CLEANFILES = $(EXTRA_PROGRAMS) + +test_rectinsert_SOURCES = \ + test-rectinsert.c \ + test-rectinsert-data.c \ + test-rectinsert-data.h \ + test-rectinsert-types.h \ + rmd_rectinsert.c + +test_rectinsert_CFLAGS = -Wall diff --git a/src/rmd.c b/src/rmd.c new file mode 100644 index 0000000..5a93e79 --- /dev/null +++ b/src/rmd.c @@ -0,0 +1,184 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" + +#include "rmd_cache.h" +#include "rmd_encode_cache.h" +#include "rmd_error.h" +#include "rmd_initialize_data.h" +#include "rmd_parseargs.h" +#include "rmd_queryextensions.h" +#include "rmd_rescue.h" +#include "rmd_setbrwindow.h" +#include "rmd_shortcuts.h" +#include "rmd_threads.h" +#include "rmd_wm_is_compositing.h" +#include "rmd_types.h" + +#include <X11/Xlib.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> + +int main(int argc, char **argv){ + ProgData pdata = {}; + EncData enc_data = {}; + CacheData cache_data = {}; + int exit_status = 0; + +#ifdef HAVE_LIBJACK + JackData jdata; + + // Give jack access to program data, mainly for program state + jdata.pdata = &pdata; + pdata.jdata = &jdata; +#endif + + rmdSetupDefaultArgs(&pdata.args); + + if (!rmdParseArgs(argc, argv, &pdata.args)) + exit(1); + + if (pdata.args.rescue_path != NULL) + exit(rmdRescue(pdata.args.rescue_path)); + + if (XInitThreads() == 0) { + fprintf(stderr, "Couldn't initialize thread support!\n"); + exit(7); + } + + if (pdata.args.display != NULL) { + pdata.dpy = XOpenDisplay(pdata.args.display); + XSetErrorHandler(rmdErrorHandler); + } else { + fprintf(stderr, "No display specified for connection!\n"); + exit(8); + } + + if (pdata.dpy == NULL) { + fprintf(stderr, "Cannot connect to X server %s\n", pdata.args.display); + exit(9); + } + + // Query display specs + pdata.specs.screen = DefaultScreen(pdata.dpy); + pdata.specs.width = DisplayWidth(pdata.dpy, pdata.specs.screen); + pdata.specs.height = DisplayHeight(pdata.dpy, pdata.specs.screen); + pdata.specs.root = RootWindow(pdata.dpy, pdata.specs.screen); + pdata.specs.visual = DefaultVisual(pdata.dpy, pdata.specs.screen); + pdata.specs.gc = DefaultGC(pdata.dpy, pdata.specs.screen); + pdata.specs.depth = DefaultDepth(pdata.dpy, pdata.specs.screen); + + if (pdata.specs.depth != 32 && pdata.specs.depth != 24 && pdata.specs.depth != 16) { + fprintf(stderr, + "Only 32bpp, 24bpp, and 16bpp" + " color depth modes are currently supported.\n"); + exit(10); + } + + if (!rmdSetBRWindow(pdata.dpy, &pdata.brwin, &pdata.specs, &pdata.args)) + exit(11); + + if (!pdata.args.nowmcheck && rmdWMIsCompositing( pdata.dpy, pdata.specs.screen ) ) { + + fprintf(stderr, "\nDetected compositing window manager.\n" + "Reverting to full screen capture at every frame.\n" + "To disable this check run with --no-wm-check\n" + "(though that is not advised, since it will " + "probably produce faulty results).\n\n"); + pdata.args.full_shots = 1; + pdata.args.noshared = 0; + } + + rmdQueryExtensions( pdata.dpy, + &pdata.args, + &pdata.damage_event, + &pdata.damage_error, + &pdata.shm_opcode); + + exit_status = rmdInitializeData(&pdata, &enc_data, &cache_data); + if (exit_status) + exit(exit_status); + + if ( !strcmp(pdata.args.pause_shortcut, pdata.args.stop_shortcut) || + rmdRegisterShortcut( pdata.dpy, pdata.specs.root, + pdata.args.pause_shortcut, + &(pdata.pause_key)) || + rmdRegisterShortcut( pdata.dpy, + pdata.specs.root, + pdata.args.stop_shortcut, + &(pdata.stop_key))) { + + fprintf(stderr, "Invalid shortcut, or shortcuts are the same!\n\nUsing defaults.\n"); + + rmdRegisterShortcut( pdata.dpy, + pdata.specs.root, + "Control+Mod1+p", + &(pdata.pause_key)); + + rmdRegisterShortcut( pdata.dpy, + pdata.specs.root, + "Control+Mod1+s", + &(pdata.stop_key)); + } + + //this is where the capturing happens. + rmdThreads(&pdata); + + XCloseDisplay(pdata.dpy); + fprintf(stderr, ".\n"); + + //encode and then cleanup cache + if (!pdata.args.encOnTheFly && !pdata.args.no_encode) { + if (!pdata.aborted) + rmdEncodeCache(&pdata); + + fprintf(stderr, "Cleanning up cache...\n"); + if (rmdPurgeCache(pdata.cache_data, !pdata.args.nosound)) + fprintf(stderr, "Some error occured while cleaning up cache!\n"); + + fprintf(stderr, "Done!!!\n"); + } + + if (pdata.aborted && pdata.args.encOnTheFly) { + if (remove(pdata.args.filename)) { + perror("Error while removing file:\n"); + return 1; + } else { + fprintf(stderr, "SIGABRT received, file %s removed\n", + pdata.args.filename); + return 0; + } + } else + fprintf(stderr, "Goodbye!\n"); + + rmdCleanUp(); + + return exit_status; +} diff --git a/src/rmd_cache.c b/src/rmd_cache.c new file mode 100644 index 0000000..1353bc2 --- /dev/null +++ b/src/rmd_cache.c @@ -0,0 +1,218 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_cache.h" + +#include "rmd_specsfile.h" +#include "rmd_types.h" + +#include <sys/types.h> +#include <unistd.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <sys/stat.h> + + +/** +*Construct an number postfixed name +* +* \param name base name +* +* \param newname modified name +* +* \n number to be used as a postfix +* +*/ +static void rmdCacheFileN(char *name, char **newname, int n) { // Nth cache file + char numbuf[8]; + + strcpy(*newname, name); + strcat(*newname, "."); + snprintf(numbuf, 8, "%d", n); + strcat(*newname, numbuf); +} + +int rmdSwapCacheFilesWrite(char *name, int n, gzFile *fp, FILE **ucfp) { + char *newname = malloc(strlen(name) + 10); + + rmdCacheFileN(name, &newname, n); + if (*fp == NULL) { + fflush(*ucfp); + fclose(*ucfp); + *ucfp = fopen(newname, "wb"); + } else { + gzflush(*fp, Z_FINISH); + gzclose(*fp); + *fp = gzopen(newname, "wb0f"); + } + free(newname); + + return ((*fp == NULL) && (*ucfp == NULL)); +} + +int rmdSwapCacheFilesRead(char *name, int n, gzFile *fp, FILE **ucfp) { + char *newname = malloc(strlen(name) + 10); + + rmdCacheFileN(name, &newname, n); + if (*fp == NULL) { + fclose(*ucfp); + *ucfp = fopen(newname, "rb"); + } else { + gzclose(*fp); + *fp = gzopen(newname, "rb"); + } + free(newname); + + return ((*fp == NULL) && (*ucfp == NULL)); +} + +int rmdPurgeCache(CacheData *cache_data_t, int sound) { + struct stat buff; + char *fname; + int exit_value = 0; + int nth_cache = 1; + + fname = malloc(strlen(cache_data_t->imgdata) + 10); + strcpy(fname, cache_data_t->imgdata); + + while (stat(fname, &buff) == 0) { + if (remove(fname)) { + fprintf(stderr, "Couldn't remove temporary file %s", cache_data_t->imgdata); + exit_value = 1; + } + rmdCacheFileN(cache_data_t->imgdata, &fname, nth_cache); + nth_cache++; + } + + free(fname); + + if (sound) { + if (remove(cache_data_t->audiodata)) { + fprintf(stderr, "Couldn't remove temporary file %s", cache_data_t->audiodata); + exit_value = 1; + } + } + + if (remove(cache_data_t->specsfile)) { + fprintf(stderr, "Couldn't remove temporary file %s", cache_data_t->specsfile); + exit_value = 1; + } + + if (remove(cache_data_t->projname)) { + fprintf(stderr, "Couldn't remove temporary directory %s", cache_data_t->projname); + exit_value = 1; + } + + return exit_value; +} + +void rmdInitCacheData(ProgData *pdata, EncData *enc_data_t, CacheData *cache_data_t) { + int width, height, pid; + char pidbuf[8]; + + //we set the buffer only since there's + //no need to initialize the encoder from now. + width = ((pdata->brwin.rrect.width + 15) >> 4) << 4; + height = ((pdata->brwin.rrect.height + 15) >> 4) << 4; + + (pdata)->enc_data = enc_data_t; + + enc_data_t->yuv.y = (unsigned char *)malloc(height * width); + enc_data_t->yuv.u = (unsigned char *)malloc(height * width / 4); + enc_data_t->yuv.v = (unsigned char *)malloc(height * width / 4); + enc_data_t->yuv.y_width = width; + enc_data_t->yuv.y_height = height; + enc_data_t->yuv.y_stride = width; + + enc_data_t->yuv.uv_width = width / 2; + enc_data_t->yuv.uv_height = height / 2; + enc_data_t->yuv.uv_stride = width / 2; + + //now we set the cache files + (pdata)->cache_data = cache_data_t; + + cache_data_t->workdir = (pdata->args).workdir; + pid = getpid(); + + snprintf( pidbuf, 8, "%d", pid ); + //names are stored relatively to current dir(i.e. no chdir) + cache_data_t->projname = malloc(strlen(cache_data_t->workdir) + 12 + strlen(pidbuf) + 3); + //projname + strcpy(cache_data_t->projname, cache_data_t->workdir); + strcat(cache_data_t->projname, "/"); + strcat(cache_data_t->projname, "rMD-session-"); + strcat(cache_data_t->projname, pidbuf); + strcat(cache_data_t->projname, "/"); + //image data + cache_data_t->imgdata = malloc(strlen(cache_data_t->projname) + 11); + strcpy(cache_data_t->imgdata, cache_data_t->projname); + strcat(cache_data_t->imgdata, "img.out"); + //audio data + cache_data_t->audiodata = malloc(strlen(cache_data_t->projname) + 10); + strcpy(cache_data_t->audiodata, cache_data_t->projname); + strcat(cache_data_t->audiodata, "audio.pcm"); + //specsfile + cache_data_t->specsfile = malloc(strlen(cache_data_t->projname) + 10); + strcpy(cache_data_t->specsfile, cache_data_t->projname); + strcat(cache_data_t->specsfile, "specs.txt"); + + //now that've got out buffers and our filenames we start + //creating the needed files + + if (mkdir(cache_data_t->projname, 0777)) { + fprintf(stderr, "Could not create temporary directory %s !!!\n", cache_data_t->projname); + exit(13); + } + + if (!pdata->args.zerocompression) { + cache_data_t->ifp = gzopen(cache_data_t->imgdata, "wb0f"); + if (cache_data_t->ifp == NULL) { + fprintf(stderr, "Could not create temporary file %s !!!\n", cache_data_t->imgdata); + exit(13); + } + } else { + cache_data_t->uncifp = fopen(cache_data_t->imgdata, "wb0f"); + if (cache_data_t->uncifp == NULL) { + fprintf(stderr, "Could not create temporary file %s !!!\n", cache_data_t->imgdata); + exit(13); + } + } + + if (!pdata->args.nosound) { + cache_data_t->afp = fopen(cache_data_t->audiodata, "wb"); + if (cache_data_t->afp == NULL) { + fprintf(stderr, "Could not create temporary file %s !!!\n", cache_data_t->audiodata); + exit(13); + } + } + + if (rmdWriteSpecsFile(pdata)) { + fprintf(stderr, "Could not write specsfile %s !!!\n", cache_data_t->specsfile); + exit(13); + } +} diff --git a/src/rmd_cache.h b/src/rmd_cache.h new file mode 100644 index 0000000..9f4acce --- /dev/null +++ b/src/rmd_cache.h @@ -0,0 +1,94 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef RMD_CACHE_H +#define RMD_CACHE_H 1 + +#include "rmd_types.h" + +#include <zlib.h> + +#include <stdio.h> + + + +/** +* Change file pointer to a new file while writting +* (file name is incremented with CacheFileN) +* +* \param name base file name +* +* \param n number to be used as a postfix +* +* \param fp File pointer if compression is used(must be NULL otherwise) +* +* \param ucfp File pointer if compression is NOT used(must be NULL otherwise) +* +* \returns 0 on Success 1 on Failure +*/ +int rmdSwapCacheFilesWrite(char *name,int n,gzFile *fp,FILE **ucfp); + +/** +* Change file pointer to a new file while reading +* (file name is incremented with CacheFileN) +* +* \param name base file name +* +* \param n number to be used as a postfix +* +* \param fp File pointer if compression is used(must be NULL otherwise) +* +* \param ucfp File pointer if compression is NOT used(must be NULL otherwise) +* +* \returns 0 on Success 1 on Failure +*/ +int rmdSwapCacheFilesRead(char *name,int n,gzFile *fp,FILE **ucfp); + +/** +* Delete all cache files +* +* \param cache_data_t Caching options(file names etc.) +* +* \returns 0 if all files and folders where deleted, 1 otherwise +*/ +int rmdPurgeCache(CacheData *cache_data_t,int sound); + +/** +* Initializes paths and everything else needed to start caching +* +* \param pdata ProgData struct containing all program data +* +* \param enc_data_t Encoding options +* +* \param cache_data_t Caching options +* +*/ +void rmdInitCacheData(ProgData *pdata, + EncData *enc_data_t, + CacheData *cache_data_t); + + +#endif diff --git a/src/rmd_cache_audio.c b/src/rmd_cache_audio.c new file mode 100644 index 0000000..fabcb39 --- /dev/null +++ b/src/rmd_cache_audio.c @@ -0,0 +1,104 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_cache_audio.h" + +#include "rmd_jack.h" +#include "rmd_types.h" + +#include <pthread.h> + +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> + + + +void *rmdCacheSoundBuffer(ProgData *pdata) { + size_t write_size = pdata->periodsize * pdata->sound_framesize; + +#ifdef HAVE_LIBJACK + void *jackbuf = NULL; + + if (pdata->args.use_jack) { + write_size = pdata->sound_framesize * pdata->jdata->buffersize; + jackbuf = malloc(pdata->sound_framesize * pdata->jdata->buffersize); + } +#endif + +//We are simply going to throw sound on the disk. +//It's sound is tiny compared to that of image, so +//compressing would reducethe overall size by only an +//insignificant fraction. + + while (pdata->running) { + SndBuffer *buff = NULL; + + pthread_mutex_lock(&pdata->pause_mutex); + while (pdata->paused) + pthread_cond_wait(&pdata->pause_cond, &pdata->pause_mutex); + pthread_mutex_unlock(&pdata->pause_mutex); + + if (!pdata->args.use_jack) { + pthread_mutex_lock(&pdata->sound_buffer_mutex); + while (!pdata->sound_buffer && pdata->running) + pthread_cond_wait(&pdata->sound_data_read, &pdata->sound_buffer_mutex); + + buff = pdata->sound_buffer; + if (buff) + pdata->sound_buffer = buff->next; + pthread_mutex_unlock(&pdata->sound_buffer_mutex); + + if (!pdata->running) + break; + + fwrite(buff->data, 1, write_size, pdata->cache_data->afp); + free(buff->data); + free(buff); + } else { +#ifdef HAVE_LIBJACK + pthread_mutex_lock(&pdata->sound_buffer_mutex); + while ( pdata->running && + jack_ringbuffer_read_space(pdata->jdata->sound_buffer) < write_size) + pthread_cond_wait(&pdata->sound_data_read, &pdata->sound_buffer_mutex); + + if (pdata->running) + jack_ringbuffer_read(pdata->jdata->sound_buffer, jackbuf, write_size); + pthread_mutex_unlock(&pdata->sound_buffer_mutex); + + if (!pdata->running) + break; + + fwrite(jackbuf, 1, write_size, pdata->cache_data->afp); +#endif + } + pdata->avd -= pdata->periodtime; + } + + fclose(pdata->cache_data->afp); + pthread_exit(&errno); +} diff --git a/src/rmd_cache_audio.h b/src/rmd_cache_audio.h new file mode 100644 index 0000000..1ba3221 --- /dev/null +++ b/src/rmd_cache_audio.h @@ -0,0 +1,42 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef CACHE_AUDIO_H +#define CACHE_AUDIO_H 1 + +#include "rmd_types.h" + + +/** +* Sound caching thread. Simply writes the pcm buffers on disk +* +* \param pdata ProgData struct containing all program data +* +*/ +void *rmdCacheSoundBuffer(ProgData *pdata); + + +#endif diff --git a/src/rmd_cache_frame.c b/src/rmd_cache_frame.c new file mode 100644 index 0000000..7b8a2f3 --- /dev/null +++ b/src/rmd_cache_frame.c @@ -0,0 +1,319 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_cache_frame.h" + +#include "rmd_yuv_utils.h" +#include "rmd_cache.h" +#include "rmd_types.h" + +#include <signal.h> +#include <string.h> +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> +#include <math.h> + + +#define BYTES_PER_MB (1024 * 1024) +#define CACHE_OUT_BUFFER_SIZE (4 * 1024) +#define CACHE_FILE_SIZE_LIMIT (500 * 1024 * 1024) + + +static int rmdFlushBlock( + unsigned char *buf, + int blockno, + int width, + int height, + int blockwidth, + gzFile fp, + FILE *ucfp, + int flush) { + + int bytes_written = 0, + block_i = (!blockwidth) ? 0 : (blockno / (width / blockwidth)),//place on the grid + block_k = (!blockwidth) ? 0 : (blockno % (width / blockwidth)); + register unsigned char *buf_reg = (&buf[(block_i * width + block_k) * blockwidth]); + static unsigned char out_buffer[CACHE_OUT_BUFFER_SIZE]; + static unsigned int out_buffer_bytes = 0; + + if (out_buffer_bytes + pow(blockwidth, 2) >= CACHE_OUT_BUFFER_SIZE || (flush && out_buffer_bytes)) { + if (ucfp == NULL) + gzwrite(fp, (void *)out_buffer, out_buffer_bytes); + else + fwrite((void *)out_buffer, 1, out_buffer_bytes, ucfp); + + bytes_written = out_buffer_bytes; + out_buffer_bytes = 0; + } + + if (!flush) { + register unsigned char *out_buf_reg = &out_buffer[out_buffer_bytes]; + + for (int j = 0;j < blockwidth; j++) { + + for(int i = 0;i < blockwidth; i++) + (*out_buf_reg++) = (*buf_reg++); + + out_buffer_bytes += blockwidth; + buf_reg += width - blockwidth; + } + } + + return bytes_written; +} + +void *rmdCacheImageBuffer(ProgData *pdata) { + + gzFile fp = NULL; + FILE *ucfp = NULL; + int index_entry_size = sizeof(u_int32_t), + blocknum_x = pdata->enc_data->yuv.y_width / Y_UNIT_WIDTH, + blocknum_y = pdata->enc_data->yuv.y_height / Y_UNIT_WIDTH, + firstrun = 1, + frameno = 0, + nbytes = 0, + nth_cache = 1; + u_int32_t ynum, unum, vnum, + y_short_blocks[blocknum_x * blocknum_y], + u_short_blocks[blocknum_x * blocknum_y], + v_short_blocks[blocknum_x * blocknum_y]; + unsigned long long int total_bytes = 0; + unsigned long long int total_received_bytes = 0; + unsigned int capture_frameno = 0; + + if (!pdata->args.zerocompression) { + fp = pdata->cache_data->ifp; + + if (fp == NULL) + exit(13); + } else { + ucfp = pdata->cache_data->uncifp; + + if (ucfp == NULL) + exit(13); + } + + while (pdata->running) { + FrameHeader fheader; + + ynum = unum = vnum = 0; + + pthread_mutex_lock(&pdata->img_buff_ready_mutex); + while (pdata->running && capture_frameno >= pdata->capture_frameno) + pthread_cond_wait(&pdata->image_buffer_ready, &pdata->img_buff_ready_mutex); + + capture_frameno = pdata->capture_frameno; + pthread_mutex_unlock(&pdata->img_buff_ready_mutex); + + pthread_mutex_lock(&pdata->pause_mutex); + while (pdata->paused) + pthread_cond_wait(&pdata->pause_cond, &pdata->pause_mutex); + pthread_mutex_unlock(&pdata->pause_mutex); + + pthread_mutex_lock(&pdata->yuv_mutex); + + //find and flush different blocks + if (firstrun) { + firstrun = 0; + for(int j = 0; j < blocknum_x * blocknum_y; j++) { + yblocks[ynum] = 1; + y_short_blocks[ynum] = j; + ynum++; + ublocks[unum] = 1; + u_short_blocks[unum] = j; + unum++; + vblocks[vnum] = 1; + v_short_blocks[vnum] = j; + vnum++; + } + } else { + /**COMPRESS ARRAYS*/ + for(int j = 0; j < blocknum_x * blocknum_y; j++) { + if (yblocks[j]) { + y_short_blocks[ynum] = j; + ynum++; + } + if (ublocks[j]) { + u_short_blocks[unum] = j; + unum++; + } + if (vblocks[j]) { + v_short_blocks[vnum] = j; + vnum++; + } + } + } + + /**WRITE FRAME TO DISK*/ + if (!pdata->args.zerocompression) { + if (ynum * 4 + unum + vnum > (blocknum_x * blocknum_y * 6) / 10) + gzsetparams(fp, 1, Z_FILTERED); + else + gzsetparams(fp, 0, Z_FILTERED); + } + + strncpy(fheader.frame_prefix, "FRAM", 4); + fheader.frameno = ++frameno; + fheader.current_total = pdata->frames_total; + + fheader.Ynum = ynum; + fheader.Unum = unum; + fheader.Vnum = vnum; + + if (!pdata->args.zerocompression) { + nbytes += gzwrite(fp, (void*)&fheader, sizeof(FrameHeader)); + //flush indexes + if (ynum) + nbytes += gzwrite(fp, (void*)y_short_blocks, ynum * index_entry_size); + + if (unum) + nbytes += gzwrite(fp, (void*)u_short_blocks, unum * index_entry_size); + + if (vnum) + nbytes += gzwrite(fp, (void*)v_short_blocks, vnum * index_entry_size); + } else { + nbytes += sizeof(FrameHeader)* + fwrite((void*)&fheader, sizeof(FrameHeader), 1, ucfp); + //flush indexes + if (ynum) + nbytes += index_entry_size * fwrite(y_short_blocks, index_entry_size, ynum, ucfp); + + if (unum) + nbytes += index_entry_size * fwrite(u_short_blocks, index_entry_size, unum, ucfp); + + if (vnum) + nbytes += index_entry_size * fwrite(v_short_blocks, index_entry_size, vnum, ucfp); + } + + //flush the blocks for each buffer + if (ynum) { + for(int j = 0; j < ynum; j++) + nbytes += rmdFlushBlock(pdata->enc_data->yuv.y, + y_short_blocks[j], + pdata->enc_data->yuv.y_width, + pdata->enc_data->yuv.y_height, + Y_UNIT_WIDTH, + fp, + ucfp, + 0); + } + + if (unum) { + for(int j = 0; j < unum; j++) + nbytes += rmdFlushBlock(pdata->enc_data->yuv.u, + u_short_blocks[j], + pdata->enc_data->yuv.uv_width, + pdata->enc_data->yuv.uv_height, + UV_UNIT_WIDTH, + fp, + ucfp, + 0); + } + + if (vnum) { + for(int j = 0; j < vnum; j++) + nbytes += rmdFlushBlock(pdata->enc_data->yuv.v, + v_short_blocks[j], + pdata->enc_data->yuv.uv_width, + pdata->enc_data->yuv.uv_height, + UV_UNIT_WIDTH, + fp, + ucfp, + 0); + } + + //release main buffer + pthread_mutex_unlock(&pdata->yuv_mutex); + + nbytes += rmdFlushBlock(NULL, 0, 0, 0, 0, fp, ucfp, 1); + /**@________________@**/ + pdata->avd += pdata->frametime; + + if (nbytes > CACHE_FILE_SIZE_LIMIT) { + if (rmdSwapCacheFilesWrite(pdata->cache_data->imgdata, nth_cache, &fp, &ucfp)) { + fprintf(stderr, "New cache file could not be created.\n" + "Ending recording...\n"); + fflush(stderr); + raise(SIGINT); //if for some reason we cannot make a new file + //we have to stop. If we are out of space, + //which means + //that encoding cannot happen either, + //InitEncoder will cause an abrupt end with an + //error code and the cache will remain intact. + //If we've chosen separate two-stages, + //the program will make a + //clean exit. + //In either case data will be preserved so if + //space is freed the recording + //can be proccessed later. + } + total_bytes += nbytes; + nth_cache++; + nbytes = 0; + } + } + total_bytes += nbytes; + + { + unsigned int bytes_per_pixel = pdata->specs.depth >= 24 ? 4 : 2; + unsigned int pixels_per_frame = pdata->enc_data->yuv.y_width * pdata->enc_data->yuv.y_height; + + total_received_bytes = ((unsigned long long int)frameno) * bytes_per_pixel * pixels_per_frame; + } + + if (total_received_bytes) { + double percent_of_data_left = (total_bytes / (double)total_received_bytes) * 100; + + fprintf(stderr, "\n" + "*********************************************\n" + "\n" + "Cached %llu MB, from %llu MB that were received.\n" + "Average cache compression ratio: %.1f %%\n" + "\n" + "*********************************************\n", + total_bytes / BYTES_PER_MB, + total_received_bytes / BYTES_PER_MB, + 100 - percent_of_data_left); + + } + + fprintf(stderr, "Saved %d frames in a total of %d requests\n", + frameno, + pdata->frames_total); + fflush(stderr); + + if (!pdata->args.zerocompression) { + gzflush(fp, Z_FINISH); + gzclose(fp); + } else { + fflush(ucfp); + fclose(ucfp); + } + + pthread_exit(&errno); +} diff --git a/src/rmd_cache_frame.h b/src/rmd_cache_frame.h new file mode 100644 index 0000000..9361e35 --- /dev/null +++ b/src/rmd_cache_frame.h @@ -0,0 +1,43 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef CACHE_FRAME_H +#define CACHE_FRAME_H 1 + +#include "rmd_types.h" + + +/** +* Image caching thread. Copies the yuv buffer, compares with the last one and +* caches the result. +* +* \param pdata ProgData struct containing all program data +* +*/ +void *rmdCacheImageBuffer(ProgData *pdata); + + +#endif diff --git a/src/rmd_capture_sound.c b/src/rmd_capture_sound.c new file mode 100644 index 0000000..2719c60 --- /dev/null +++ b/src/rmd_capture_sound.c @@ -0,0 +1,165 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_capture_sound.h" + +#include "rmd_jack.h" +#include "rmd_opendev.h" +#include "rmd_types.h" + +#include <pthread.h> +#include <string.h> +#include <errno.h> +#include <sys/types.h> +#include <sys/uio.h> +#include <unistd.h> +#include <stdlib.h> + + +void *rmdCaptureSound(ProgData *pdata) { + +#ifdef HAVE_LIBASOUND + int frames = pdata->periodsize; +#endif + //start capturing only after first frame is taken + usleep(pdata->frametime); + + while (pdata->running) { + int sret = 0; + SndBuffer *newbuf, *tmp; + + if (pdata->paused) { +#ifdef HAVE_LIBASOUND + if (!pdata->hard_pause) { + snd_pcm_pause(pdata->sound_handle, 1); + pthread_mutex_lock(&pdata->pause_mutex); + pthread_cond_wait(&pdata->pause_cond, &pdata->pause_mutex); + pthread_mutex_unlock(&pdata->pause_mutex); + snd_pcm_pause(pdata->sound_handle, 0); + } else {//device doesn't support pause(is this the norm?mine doesn't) + snd_pcm_close(pdata->sound_handle); + pthread_mutex_lock(&pdata->pause_mutex); + pthread_cond_wait(&pdata->pause_cond, &pdata->pause_mutex); + pthread_mutex_unlock(&pdata->pause_mutex); + pdata->sound_handle = + rmdOpenDev(pdata->args.device, + &pdata->args.channels, + &pdata->args.frequency, + &pdata->args.buffsize, + NULL, + NULL, + NULL//let's hope that the device capabilities + //didn't magically change + ); + if (pdata->sound_handle == NULL) { + fprintf(stderr, "Couldn't reopen sound device.Exiting\n"); + pdata->running = FALSE; + errno = 3; + pthread_exit(&errno); + } + } +#else + close(pdata->sound_handle); + pthread_mutex_lock(&pdata->pause_mutex); + pthread_cond_wait(&pdata->pause_cond, &pdata->pause_mutex); + pthread_mutex_unlock(&pdata->pause_mutex); + pdata->sound_handle = rmdOpenDev( pdata->args.device, + pdata->args.channels, + pdata->args.frequency); + if (pdata->sound_handle < 0) { + fprintf(stderr, "Couldn't reopen sound device. Exiting\n"); + pdata->running = FALSE; + errno = 3; + pthread_exit(&errno); + } +#endif + } + + //create new buffer + newbuf = (SndBuffer *)malloc(sizeof(SndBuffer)); +#ifdef HAVE_LIBASOUND + newbuf->data = (signed char *)malloc(frames * pdata->sound_framesize); +#else + newbuf->data = (signed char *)malloc((pdata->args.buffsize << 1) * pdata->args.channels); +#endif + newbuf->next = NULL; + + //read data into new buffer +#ifdef HAVE_LIBASOUND + while (sret<frames) { + int temp_sret = snd_pcm_readi( pdata->sound_handle, + newbuf->data + pdata->sound_framesize * sret, + frames-sret); + if (temp_sret == -EPIPE) { + fprintf(stderr, "%s: Overrun occurred.\n", + snd_strerror(temp_sret)); + snd_pcm_prepare(pdata->sound_handle); + } else if (temp_sret < 0) { + fprintf(stderr, "An error occured while reading sound data:\n" + " %s\n", + snd_strerror(temp_sret)); + snd_pcm_prepare(pdata->sound_handle); + } else + sret += temp_sret; + } +#else + sret = 0; + //oss recording loop + do { + int temp_sret = read( pdata->sound_handle, + &newbuf->data[sret], + (pdata->args.buffsize << 1) * + pdata->args.channels)-sret; + if (temp_sret < 0) { + fprintf(stderr, "An error occured while reading from soundcard" + "%s\nError description:\n%s\n", + pdata->args.device, strerror(errno)); + } else + sret += temp_sret; + } while (sret < (pdata->args.buffsize << 1) * pdata->args.channels); +#endif + //queue the new buffer + pthread_mutex_lock(&pdata->sound_buffer_mutex); + tmp = pdata->sound_buffer; + if (!tmp) + pdata->sound_buffer = newbuf; + else { + while (tmp->next != NULL) + tmp = tmp->next; + + tmp->next = newbuf; + } + pthread_cond_signal(&pdata->sound_data_read); + pthread_mutex_unlock(&pdata->sound_buffer_mutex); + } +#ifdef HAVE_LIBASOUND + snd_pcm_close(pdata->sound_handle); +#else + close(pdata->sound_handle); +#endif + pthread_exit(&errno); +} diff --git a/src/rmd_capture_sound.h b/src/rmd_capture_sound.h new file mode 100644 index 0000000..b403fa8 --- /dev/null +++ b/src/rmd_capture_sound.h @@ -0,0 +1,42 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef CAPTURE_SOUND_H +#define CAPTURE_SOUND_H 1 + +#include "rmd_types.h" + + +/** +* Sound capturing thread. Data are placed on a +* list to be picked up by other threads. +* +* \param pdata ProgData struct containing all program data +*/ +void *rmdCaptureSound(ProgData *pdata); + + +#endif diff --git a/src/rmd_encode_cache.c b/src/rmd_encode_cache.c new file mode 100644 index 0000000..1e0727c --- /dev/null +++ b/src/rmd_encode_cache.c @@ -0,0 +1,72 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_encode_cache.h" + +#include "rmd_flush_to_ogg.h" +#include "rmd_init_encoder.h" +#include "rmd_load_cache.h" +#include "rmd_types.h" + +#include <pthread.h> + +#include <stdio.h> +#include <stdlib.h> + + + +void rmdEncodeCache(ProgData *pdata){ + pthread_t flush_to_ogg_t, load_cache_t; + + fprintf(stderr, "STATE:ENCODING\n"); + fprintf(stderr, "Encoding started!\nThis may take several minutes.\n" + "Pressing Ctrl-C will cancel the procedure" + " (resuming will not be possible, but\n" + "any portion of the video, which is already encoded won't be deleted).\n" + "Please wait...\n"); + + pdata->running = TRUE; + rmdInitEncoder(pdata, pdata->enc_data, 1); + //load encoding and flushing threads + if (!pdata->args.nosound) { + //before we start loading again + //we need to free any left-overs + while (pdata->sound_buffer != NULL) { + free(pdata->sound_buffer->data); + pdata->sound_buffer = pdata->sound_buffer->next; + } + } + pthread_create(&flush_to_ogg_t, NULL, (void *)rmdFlushToOgg, (void *)pdata); + + //start loading image and audio + pthread_create(&load_cache_t, NULL, (void *)rmdLoadCache, (void *)pdata); + + //join and finish + pthread_join(load_cache_t, NULL); + fprintf(stderr, "Encoding finished!\nWait a moment please...\n"); + pthread_join(flush_to_ogg_t, NULL); +} diff --git a/src/rmd_encode_cache.h b/src/rmd_encode_cache.h new file mode 100644 index 0000000..4c37f97 --- /dev/null +++ b/src/rmd_encode_cache.h @@ -0,0 +1,41 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef ENCODE_CACHE_H +#define ENCODE_CACHE_H 1 + +#include "rmd_types.h" + + +/** +* Encode cache into an +* ogg stream. +* \param pdata ProgData struct containing all program data +*/ +void rmdEncodeCache(ProgData *pdata); + + +#endif diff --git a/src/rmd_encode_image_buffer.c b/src/rmd_encode_image_buffer.c new file mode 100644 index 0000000..c234aa4 --- /dev/null +++ b/src/rmd_encode_image_buffer.c @@ -0,0 +1,99 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_encode_image_buffer.h" + +#include "rmd_types.h" + +#include <errno.h> + + +void *rmdEncodeImageBuffer(ProgData *pdata) { + unsigned int encode_frameno = 0; + + pdata->th_encoding_clean = 0; + + while (pdata->running) { + EncData *enc_data = pdata->enc_data; + + pthread_mutex_lock(&pdata->img_buff_ready_mutex); + while (pdata->running && encode_frameno >= pdata->capture_frameno) + pthread_cond_wait(&pdata->image_buffer_ready, &pdata->img_buff_ready_mutex); + encode_frameno = pdata->capture_frameno; + pthread_mutex_unlock(&pdata->img_buff_ready_mutex); + + pthread_mutex_lock(&pdata->pause_mutex); + while (pdata->paused) + pthread_cond_wait(&pdata->pause_cond, &pdata->pause_mutex); + pthread_mutex_unlock(&pdata->pause_mutex); + + pthread_mutex_lock(&pdata->yuv_mutex); + if (theora_encode_YUVin(&enc_data->m_th_st, &enc_data->yuv)) { + fprintf(stderr, "Encoder not ready!\n"); + pthread_mutex_unlock(&pdata->yuv_mutex); + } else { + pthread_mutex_unlock(&pdata->yuv_mutex); + + if (theora_encode_packetout(&enc_data->m_th_st, 0, &enc_data->m_ogg_pckt1) == 1) { + pthread_mutex_lock(&pdata->libogg_mutex); + ogg_stream_packetin(&enc_data->m_ogg_ts, &enc_data->m_ogg_pckt1); + pdata->avd += pdata->frametime; + pthread_mutex_unlock(&pdata->libogg_mutex); + } + } + } + + //last packet + pthread_mutex_lock(&pdata->theora_lib_mutex); + pdata->th_encoding_clean = 1; + pthread_cond_signal(&pdata->theora_lib_clean); + pthread_mutex_unlock(&pdata->theora_lib_mutex); + + pthread_exit(&errno); +} + +//this function is meant to be called normally +//not through a thread of it's own +void rmdSyncEncodeImageBuffer(ProgData *pdata) { + EncData *enc_data = pdata->enc_data; + + if (theora_encode_YUVin(&enc_data->m_th_st, &enc_data->yuv)) { + fprintf(stderr, "Encoder not ready!\n"); + return; + } + + if (theora_encode_packetout(&enc_data->m_th_st, !pdata->running, &enc_data->m_ogg_pckt1) == 1) { + pthread_mutex_lock(&pdata->libogg_mutex); + ogg_stream_packetin(&enc_data->m_ogg_ts, &enc_data->m_ogg_pckt1); + + if (!pdata->running) + enc_data->m_ogg_ts.e_o_s = 1; + + pdata->avd += pdata->frametime; + pthread_mutex_unlock(&pdata->libogg_mutex); + } +} diff --git a/src/rmd_encode_image_buffer.h b/src/rmd_encode_image_buffer.h new file mode 100644 index 0000000..e5ca3db --- /dev/null +++ b/src/rmd_encode_image_buffer.h @@ -0,0 +1,50 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef ENCODE_IMAGE_BUFFER_H +#define ENCODE_IMAGE_BUFFER_H 1 + +#include "rmd_types.h" + + +/** +* feed a yuv buffer to the theora encoder and submit outcome to +* the ogg stream. +* \param pdata ProgData struct containing all program data +*/ +void *rmdEncodeImageBuffer(ProgData *pdata); + +/** +* As rmdEncodeImageBuffer, only with the assumption that +* this is not a thread on it's own +* +* \param pdata ProgData struct containing all program data +* +*/ +void rmdSyncEncodeImageBuffer(ProgData *pdata); + + +#endif diff --git a/src/rmd_encode_sound_buffer.c b/src/rmd_encode_sound_buffer.c new file mode 100644 index 0000000..5fa1dc6 --- /dev/null +++ b/src/rmd_encode_sound_buffer.c @@ -0,0 +1,178 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_encode_sound_buffer.h" + +#include "rmd_jack.h" +#include "rmd_types.h" + +#include <pthread.h> + +#include <stdlib.h> +#include <errno.h> + + +void *rmdEncodeSoundBuffer(ProgData *pdata) { + int sampread = pdata->periodsize; +#ifdef HAVE_LIBJACK + void *jackbuf = NULL; + + if (pdata->args.use_jack) + jackbuf = malloc(pdata->sound_framesize * pdata->jdata->buffersize); +#endif + + pdata->v_encoding_clean = 0; + while (pdata->running) { + float **vorbis_buffer; + SndBuffer *buff = NULL; + + pthread_mutex_lock(&pdata->pause_mutex); + while (pdata->paused) + pthread_cond_wait(&pdata->pause_cond, &pdata->pause_mutex); + pthread_mutex_unlock(&pdata->pause_mutex); + + if (!pdata->args.use_jack) { + pthread_mutex_lock(&pdata->sound_buffer_mutex); + while (!pdata->sound_buffer && pdata->running) + pthread_cond_wait(&pdata->sound_data_read, &pdata->sound_buffer_mutex); + + buff = pdata->sound_buffer; + if (buff) + pdata->sound_buffer = buff->next; + pthread_mutex_unlock(&pdata->sound_buffer_mutex); + + if (!pdata->running) + break; + + vorbis_buffer = vorbis_analysis_buffer(&pdata->enc_data->m_vo_dsp, sampread); + + for (int i = 0, count = 0; i < sampread; i++) { + for (int j = 0; j < pdata->args.channels; j++) { + vorbis_buffer[j][i] = ((buff->data[count + 1] << 8) | + (0x00ff & (int)buff->data[count])) / + 32768.f; + count += 2; + } + } + free(buff->data); + free(buff); + } else { +#ifdef HAVE_LIBJACK + + pthread_mutex_lock(&pdata->sound_buffer_mutex); + while ( pdata->running && + jack_ringbuffer_read_space(pdata->jdata->sound_buffer) < + pdata->sound_framesize * pdata->jdata->buffersize) + pthread_cond_wait(&pdata->sound_data_read, &pdata->sound_buffer_mutex); + + if (pdata->running) + jack_ringbuffer_read( pdata->jdata->sound_buffer, + jackbuf, + (pdata->sound_framesize * + pdata->jdata->buffersize) + ); + + pthread_mutex_unlock(&pdata->sound_buffer_mutex); + + if (!pdata->running) + break; + + vorbis_buffer = vorbis_analysis_buffer(&pdata->enc_data->m_vo_dsp, sampread); + + for (int j = 0, count = 0; j < pdata->args.channels; j++) { + for (int i = 0; i < sampread; i++) { + vorbis_buffer[j][i] = ((float*)jackbuf)[count]; + count++; + } + } +#endif + } + vorbis_analysis_wrote(&pdata->enc_data->m_vo_dsp, sampread); + + pthread_mutex_lock(&pdata->libogg_mutex); + while (vorbis_analysis_blockout(&pdata->enc_data->m_vo_dsp, &pdata->enc_data->m_vo_block) == 1) { + + vorbis_analysis(&pdata->enc_data->m_vo_block, NULL); + vorbis_bitrate_addblock(&pdata->enc_data->m_vo_block); + + while (vorbis_bitrate_flushpacket(&pdata->enc_data->m_vo_dsp, &pdata->enc_data->m_ogg_pckt2)) { + ogg_stream_packetin(&pdata->enc_data->m_ogg_vs, &pdata->enc_data->m_ogg_pckt2); + } + } + pthread_mutex_unlock(&pdata->libogg_mutex); + + /* this needs synchronizing */ + pdata->avd -= pdata->periodtime; + } + + pthread_mutex_lock(&pdata->vorbis_lib_mutex); + pdata->v_encoding_clean = 1; + pthread_cond_signal(&pdata->vorbis_lib_clean); + pthread_mutex_unlock(&pdata->vorbis_lib_mutex); + pthread_exit(&errno); +} + +void rmdSyncEncodeSoundBuffer(ProgData *pdata, signed char *buff) { + int sampread = (buff != NULL) ? pdata->periodsize : 0; + float **vorbis_buffer = vorbis_analysis_buffer(&pdata->enc_data->m_vo_dsp, sampread); + + if (!pdata->args.use_jack) { + for (int i = 0, count = 0; i < sampread; i++) { + for (int j = 0; j < pdata->args.channels; j++) { + vorbis_buffer[j][i] = ((buff[count + 1] << 8) | + (0x00ff & (int)buff[count])) + / 32768.f; + count += 2; + } + } + } else { + for (int j = 0, count = 0; j < pdata->args.channels; j++) { + for (int i = 0; i < sampread; i++) { + vorbis_buffer[j][i] = ((float *)buff)[count]; + count++; + } + } + } + + vorbis_analysis_wrote(&pdata->enc_data->m_vo_dsp, sampread); + + pthread_mutex_lock(&pdata->libogg_mutex); + while (vorbis_analysis_blockout(&pdata->enc_data->m_vo_dsp, &pdata->enc_data->m_vo_block) == 1) { + + vorbis_analysis(&pdata->enc_data->m_vo_block, NULL); + vorbis_bitrate_addblock(&pdata->enc_data->m_vo_block); + + while (vorbis_bitrate_flushpacket(&pdata->enc_data->m_vo_dsp, &pdata->enc_data->m_ogg_pckt2)) + ogg_stream_packetin(&pdata->enc_data->m_ogg_vs, &pdata->enc_data->m_ogg_pckt2); + } + pthread_mutex_unlock(&pdata->libogg_mutex); + + if (!pdata->running) + pdata->enc_data->m_ogg_vs.e_o_s = 1; + + pdata->avd -= pdata->periodtime; +} diff --git a/src/rmd_encode_sound_buffer.h b/src/rmd_encode_sound_buffer.h new file mode 100644 index 0000000..7d5c312 --- /dev/null +++ b/src/rmd_encode_sound_buffer.h @@ -0,0 +1,51 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef ENCODE_SOUND_BUFFER_H +#define ENCODE_SOUND_BUFFER_H 1 + +#include "rmd_types.h" + + +/** +* Sound encoding thread. Picks up data from the buffer queue , +* encodes and places them on the vorbis stream. +* +* \param pdata ProgData struct containing all program data +*/ +void *rmdEncodeSoundBuffer(ProgData *pdata); + +/** +* As rmdEncodeSoundBuffer, only with the assumption that +* this is not a thread on it's own +* +* \param pdata ProgData struct containing all program data +* +*/ +void rmdSyncEncodeSoundBuffer(ProgData *pdata,signed char *buff); + + +#endif diff --git a/src/rmd_error.c b/src/rmd_error.c new file mode 100644 index 0000000..ba95198 --- /dev/null +++ b/src/rmd_error.c @@ -0,0 +1,59 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_error.h" + +#include <X11/Xlib.h> +#include <X11/Xlibint.h> + +#include <stdio.h> +#include <stdlib.h> + + + +int rmdErrorHandler(Display *dpy, XErrorEvent *e) +{ + char error_desc[1024]; + + XGetErrorText(dpy, e->error_code, error_desc, sizeof(error_desc)); + fprintf(stderr, "X Error: %s\n", error_desc); + fflush(stderr); + + if ((e->error_code==BadWindow)&&(e->request_code==X_GetWindowAttributes)) { + fprintf(stderr, "BadWindow on XGetWindowAttributes.\nIgnoring...\n"); + fflush(stderr); + return 0; + } + + if ((e->error_code==BadAccess)&&(e->request_code==X_GrabKey)) { + fprintf(stderr, "Bad Access on XGrabKey.\n" "Shortcut already assigned.\n"); + fflush(stderr); + return 0; + } + + exit(1); +} diff --git a/src/rmd_error.h b/src/rmd_error.h new file mode 100644 index 0000000..4d27264 --- /dev/null +++ b/src/rmd_error.h @@ -0,0 +1,49 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef RMD_ERROR_H +#define RMD_ERROR_H 1 + +#include "rmd_types.h" + + +/* + * Handling of X errors. + * Ignores, bad access when registering shortcuts + * and BadWindow on XQueryTree + * + * \param dpy Connection to the X Server + * + * \param e XErrorEvent struct containing error info + * + * \returns 0 on the two ignored cases, calls exit(1) + * otherwise. + * + */ +int rmdErrorHandler(Display *dpy,XErrorEvent *e); + + +#endif diff --git a/src/rmd_flush_to_ogg.c b/src/rmd_flush_to_ogg.c new file mode 100644 index 0000000..87308a6 --- /dev/null +++ b/src/rmd_flush_to_ogg.c @@ -0,0 +1,235 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_flush_to_ogg.h" + +#include "rmd_encode_image_buffer.h" +#include "rmd_encode_sound_buffer.h" +#include "rmd_types.h" + +#include <pthread.h> + +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> + + + +//we copy the page because the next call to ogg_stream_pageout +//will invalidate it. But we must have pages from +//both streams at every time in +//order to do correct multiplexing +static void page_copy(ogg_page *new, ogg_page *old) { + + new->header_len = old->header_len; + new->header = malloc(new->header_len); + new->body_len = old->body_len; + new->body = malloc(new->body_len); + + memcpy(new->header, old->header, new->header_len); + memcpy(new->body, old->body, new->body_len); +} + +//free our copy +static void page_free(ogg_page *pg) { + pg->header_len = pg->body_len = 0; + free(pg->header); + free(pg->body); +} + +void *rmdFlushToOgg(ProgData *pdata) { + int videoflag = 0, audioflag = 0; + double video_bytesout = 0, audio_bytesout = 0; + ogg_page videopage, //owned by libogg + videopage_copy, //owned by the application + audiopage, //owned by libogg + audiopage_copy; //owned by the application + + double audiotime = 0; + double videotime = 0; + int th_st_fin = 0, + v_st_fin = (pdata->args.nosound); + + while (!(th_st_fin && v_st_fin)) { + int audio_or_video = 0; + + if (pdata->running) { + pthread_mutex_lock(&pdata->libogg_mutex); + if (!videoflag) { + videoflag = ogg_stream_pageout(&pdata->enc_data->m_ogg_ts, &videopage); + videotime = videoflag ? theora_granule_time( + &pdata->enc_data->m_th_st, + ogg_page_granulepos(&videopage) + ) : -1; + + if (videoflag) + page_copy(&videopage_copy, &videopage); + } + + if (!pdata->args.nosound && !audioflag) { + audioflag = ogg_stream_pageout(&pdata->enc_data->m_ogg_vs, &audiopage); + audiotime = audioflag ? vorbis_granule_time( + &pdata->enc_data->m_vo_dsp, + ogg_page_granulepos(&audiopage) + ) : -1; + + if (audioflag) + page_copy(&audiopage_copy, &audiopage); + } + pthread_mutex_unlock(&pdata->libogg_mutex); + } else { + if (!th_st_fin && !videoflag) { + pthread_mutex_lock(&pdata->libogg_mutex); + videoflag = ogg_stream_flush(&pdata->enc_data->m_ogg_ts, &videopage); + videotime = videoflag ? theora_granule_time( + &pdata->enc_data->m_th_st, + ogg_page_granulepos(&videopage) + ) : -1; + + if (videoflag) + page_copy(&videopage_copy, &videopage); + pthread_mutex_unlock(&pdata->libogg_mutex); + + //we need the last page to properly close the stream + if (!videoflag) { + pthread_mutex_lock(&pdata->theora_lib_mutex); + while (!pdata->th_encoding_clean) + pthread_cond_wait(&pdata->theora_lib_clean, &pdata->theora_lib_mutex); + pthread_mutex_unlock(&pdata->theora_lib_mutex); + rmdSyncEncodeImageBuffer(pdata); + } + } + + if (!pdata->args.nosound && !v_st_fin && !audioflag) { + pthread_mutex_lock(&pdata->libogg_mutex); + audioflag = ogg_stream_flush(&pdata->enc_data->m_ogg_vs, &audiopage); + audiotime = audioflag ? vorbis_granule_time( + &pdata->enc_data->m_vo_dsp, + ogg_page_granulepos(&audiopage) + ) : -1; + + if (audioflag) + page_copy(&audiopage_copy, &audiopage); + pthread_mutex_unlock(&pdata->libogg_mutex); + + //we need the last page to properly close the stream + if (!audioflag) { + pthread_mutex_lock(&pdata->vorbis_lib_mutex); + while (!pdata->v_encoding_clean) + pthread_cond_wait(&pdata->vorbis_lib_clean, &pdata->vorbis_lib_mutex); + pthread_mutex_unlock(&pdata->vorbis_lib_mutex); + rmdSyncEncodeSoundBuffer(pdata, NULL); + } + } + } + +#if 0 + /* I don't understand what this is about, if these are finished we want to lose + * their pages? + */ + if (th_st_fin) + videoflag=0; + + if (v_st_fin) + audioflag=0; +#endif + if ((!audioflag && !v_st_fin && !pdata->args.nosound) || (!videoflag && !th_st_fin)) { + usleep(10000); + continue; + } + + if (!audioflag) { + audio_or_video = 1; + } else if (!videoflag) { + audio_or_video = 0; + } else { + if (audiotime < videotime) + audio_or_video = 0; + else + audio_or_video = 1; + } + + if (audio_or_video == 1) { + video_bytesout += fwrite( videopage_copy.header, 1, + videopage_copy.header_len, + pdata->enc_data->fp); + + video_bytesout += fwrite( videopage_copy.body, 1, + videopage_copy.body_len, + pdata->enc_data->fp); + videoflag = 0; + + if (!pdata->running) { + pthread_mutex_lock(&pdata->libogg_mutex); + if (ogg_page_eos(&videopage_copy)) + th_st_fin = 1; + pthread_mutex_unlock(&pdata->libogg_mutex); + } + + page_free(&videopage_copy); + } else { + audio_bytesout += fwrite( audiopage_copy.header, 1, + audiopage_copy.header_len, + pdata->enc_data->fp); + + audio_bytesout += fwrite( audiopage_copy.body, 1, + audiopage_copy.body_len, + pdata->enc_data->fp); + audioflag = 0; + + if (!pdata->running) { + pthread_mutex_lock(&pdata->libogg_mutex); + if (ogg_page_eos(&audiopage_copy)) + v_st_fin = 1; + pthread_mutex_unlock(&pdata->libogg_mutex); + } + + page_free(&audiopage_copy); + } + } + + pthread_mutex_lock(&pdata->libogg_mutex); + ogg_stream_clear(&pdata->enc_data->m_ogg_ts); + + if (!pdata->args.nosound) + ogg_stream_clear(&pdata->enc_data->m_ogg_vs); + + pthread_mutex_unlock(&pdata->libogg_mutex); + + theora_clear(&pdata->enc_data->m_th_st); + + if (pdata->enc_data->fp) + fclose(pdata->enc_data->fp); + + fprintf(stderr, "\r \nDone.\nWritten %.0f bytes\n" + "(%.0f of which were video data and %.0f audio data)\n\n", + video_bytesout + audio_bytesout, + video_bytesout, audio_bytesout); + + pthread_exit(&errno); +} diff --git a/src/rmd_flush_to_ogg.h b/src/rmd_flush_to_ogg.h new file mode 100644 index 0000000..64094a8 --- /dev/null +++ b/src/rmd_flush_to_ogg.h @@ -0,0 +1,40 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef FLUSH_TO_OGG_H +#define FLUSH_TO_OGG_H 1 + +#include "rmd_types.h" + + +/** +* Query theora and vorbis streams for ready packages and +* flush them on the disk +* \param pdata ProgData struct containing all program data +*/ +void *rmdFlushToOgg(ProgData *pdata); + +#endif diff --git a/src/rmd_frame.c b/src/rmd_frame.c new file mode 100644 index 0000000..ee5c4d8 --- /dev/null +++ b/src/rmd_frame.c @@ -0,0 +1,142 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_frame.h" + +#include <X11/Xlib.h> +#include <X11/extensions/shape.h> + +#include <stdio.h> +#include <stdlib.h> + + +#define BORDER_WIDTH 6 +#define OUTLINE_WIDTH 1 + + +void rmdDrawFrame( Display *dpy, + int screen, + Window win, + int width, + int height) { + + GC gc; + XGCValues gcv; + XColor white, white_e, black, black_e; + unsigned long gcmask = GCForeground; + + XAllocNamedColor(dpy, DefaultColormap(dpy, screen), "white", &white, &white_e); + XAllocNamedColor(dpy, DefaultColormap(dpy, screen), "black", &black, &black_e); + + gcv.foreground = black.pixel; + gc = XCreateGC(dpy, win, gcmask, &gcv); + XFillRectangle( dpy, + win, + gc, + OUTLINE_WIDTH, + OUTLINE_WIDTH, + width + (BORDER_WIDTH-OUTLINE_WIDTH) * 2, + height + (BORDER_WIDTH-OUTLINE_WIDTH) * 2); + gcv.foreground = white.pixel; + XChangeGC(dpy, gc, gcmask, &gcv); + XFillRectangle( dpy, + win, + gc, + BORDER_WIDTH-OUTLINE_WIDTH, + BORDER_WIDTH-OUTLINE_WIDTH, + width + OUTLINE_WIDTH * 2, + height + OUTLINE_WIDTH * 2); + + XFreeGC(dpy, gc); + +} + +void rmdMoveFrame( Display *dpy, + Window win, + int x, + int y) { + + XMoveWindow(dpy, win, x-BORDER_WIDTH, y-BORDER_WIDTH); +// XSync(pdata->dpy, False); +} + +Window rmdFrameInit( Display *dpy, + int screen, + Window root, + int x, + int y, + int width, + int height) { + + XSetWindowAttributes attribs; + XColor white, white_e; + Window win; + unsigned long valuemask = CWBackPixmap|CWBackPixel| + CWSaveUnder|CWOverrideRedirect|CWColormap; + + XAllocNamedColor(dpy, DefaultColormap(dpy, screen), "white", &white, &white_e); + + attribs.background_pixmap = None; + attribs.background_pixel = white.pixel; + attribs.save_under = True; + attribs.override_redirect = True; + attribs.colormap = DefaultColormap(dpy, screen); + + win = XCreateWindow( dpy, + root, + x - BORDER_WIDTH, + y - BORDER_WIDTH, + width + BORDER_WIDTH * 2, + height + BORDER_WIDTH * 2, + 0, + CopyFromParent, + InputOutput, + CopyFromParent, + valuemask, + &attribs); + + XRectangle rect; + rect.x = rect.y = BORDER_WIDTH; + rect.width = width; + rect.height = height; + + XShapeCombineRectangles( dpy, + win, + ShapeBounding, + 0, + 0, + &rect, + 1, + ShapeSubtract, + 0); + + XMapWindow(dpy, win); + + rmdDrawFrame(dpy, screen, win, width, height); + + return win; +} diff --git a/src/rmd_frame.h b/src/rmd_frame.h new file mode 100644 index 0000000..c3969f8 --- /dev/null +++ b/src/rmd_frame.h @@ -0,0 +1,101 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef RMD_FRAME_H +#define RMD_FRAME_H 1 + +#include "rmd_types.h" + + +/* + * Create a frame that marks the recording area. + * + * \param dpy Connection to the X Server + * + * \param screen Recorded screen + * + * \param root Root window of the display + * + * \param x X pos of the recorded area + * + * \param y Y pos of the recorded area + * + * \param width Width of the recorded area + * + * \param height Height of the recorded area + * + * \returns The WindowID of the frame + * + */ +Window rmdFrameInit(Display *dpy, + int screen, + Window root, + int x, + int y, + int width, + int height); + + +/* + * Move the frame (subtracts the borderwidth) + * + * \param dpy Connection to the X Server + * + * \param win WindowId of the frame + * + * \param x New X pos of the recorded area + * + * \param y New Y pos of the recorded area + * + */ +void rmdMoveFrame(Display *dpy, + Window win, + int x, + int y); + + +/* + * Redraw the frame that marks the recording area. + * + * \param dpy Connection to the X Server + * + * \param screen Recorded screen + * + * \param win WindoID of the frame + * + * \param width Width of the recorded area + * + * \param height Height of the recorded area + * + */ +void rmdDrawFrame(Display *dpy, + int screen, + Window win, + int width, + int height); + + +#endif diff --git a/src/rmd_get_frame.c b/src/rmd_get_frame.c new file mode 100644 index 0000000..a9e4daa --- /dev/null +++ b/src/rmd_get_frame.c @@ -0,0 +1,593 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_get_frame.h" + +#include "rmd_cache.h" +#include "rmd_frame.h" +#include "rmd_getzpixmap.h" +#include "rmd_poll_events.h" +#include "rmd_rectinsert.h" +#include "rmd_update_image.h" +#include "rmd_yuv_utils.h" +#include "rmd_types.h" + +#include <X11/extensions/Xfixes.h> +#include <X11/extensions/XShm.h> + +#include <limits.h> +#include <pthread.h> +#include <sys/shm.h> +#include <errno.h> +#include <stdlib.h> + + +/* clip_event_area dejavu */ +static void clip_dummy_pointer_area(XRectangle *area, XRectangle *clip, XRectangle *res) +{ + res->x = (((area->x + area->width >= clip->x) && + (area->x <= clip->x + clip->width)) ? + ((area->x <= clip->x) ? clip->x : area->x) : -1); + + res->y = (((area->y + area->height >= clip->y) && + (area->y <= clip->y + clip->height)) ? + ((area->y <= clip->y) ? clip->y : area->y) : -1); + + res->width = (area->x <= clip->x) ? area->width - (clip->x - area->x) : + (area->x <= clip->x + clip->width) ? + (clip->width - area->x + clip->x < area->width) ? + clip->width - area->x + clip->x : area->width : 0; + + res->height = (area->y <= clip->y) ? area->height - (clip->y - area->y) : + (area->y <= clip->y + clip->height) ? + (clip->height - area->y + clip->y < area->height) ? + clip->height - area->y + clip->y : area->height : 0; + + if (res->x + res->width > clip->x + clip->width) + res->width = clip->x + clip->width - res->x; + + if (res->y + res->height > clip->y + clip->height) + res->height = clip->y + clip->height - res->y; +} + +#define MARK_BUFFER_AREA_C( data, \ + x_tm, \ + y_tm, \ + width_tm, \ + height_tm, \ + buffer_width, \ + __depth__) { \ + \ + register u_int##__depth__##_t *datapi = \ + ((u_int##__depth__##_t *)data) + y_tm * buffer_width + x_tm; \ + \ + for(int k = 0; k < height_tm; k++) { \ + for(int i = 0; i < width_tm; i++) { \ + *datapi += 1; \ + datapi++; \ + } \ + datapi += buffer_width - width_tm; \ + } \ +} + +static void mark_buffer_area( unsigned char *data, + int x_tm, int y_tm, + int width_tm, int height_tm, + int buffer_width, int depth) { + + if ((depth == 24) || (depth == 32)) { + MARK_BUFFER_AREA_C( data, + x_tm, + y_tm, + width_tm, + height_tm, + buffer_width, + 32); + } else { + MARK_BUFFER_AREA_C( data, + x_tm, + y_tm, + width_tm, + height_tm, + buffer_width, + 16); + } +} + +//besides taking the first screenshot, this functions primary purpose is to +//initialize the structures and memory. +static int rmdFirstFrame(ProgData *pdata, Image *image) { + const XRectangle *rrect = &pdata->brwin.rrect; + + if (pdata->args.noshared) { + image->ximage = XGetImage( pdata->dpy, + pdata->specs.root, + rrect->x, + rrect->y, + rrect->width, + rrect->height, + AllPlanes, + ZPixmap); + } else { + image->ximage = XShmCreateImage(pdata->dpy, + pdata->specs.visual, + pdata->specs.depth, + ZPixmap, + NULL, + &image->shm_info, + rrect->width, + rrect->height); + + image->shm_info.shmid = shmget( IPC_PRIVATE, + image->ximage->bytes_per_line * + image->ximage->height, + IPC_CREAT|0777); + + if (image->shm_info.shmid == -1) { + fprintf(stderr, "Failed to obtain Shared Memory segment!\n"); + return 12; + } + + image->shm_info.shmaddr = image->ximage->data = shmat(image->shm_info.shmid, NULL, 0); + image->shm_info.readOnly = False; + shmctl(image->shm_info.shmid, IPC_RMID, NULL); + + if (!XShmAttach(pdata->dpy, &image->shm_info)) { + fprintf(stderr, "Failed to attach shared memory to proccess.\n"); + return 12; + } + + XShmGetImage( pdata->dpy, + pdata->specs.root, + image->ximage, + rrect->x, + rrect->y, + AllPlanes); + } + + rmdUpdateYuvBuffer( &pdata->enc_data->yuv, + (unsigned char *)image->ximage->data, + NULL, + 0, + 0, + rrect->width, + rrect->height, + pdata->args.no_quick_subsample, + pdata->specs.depth); + + return 0; +} + +//make a deep copy +static void rmdBRWinCpy(BRWindow *target, BRWindow *source) { + target->winrect = source->winrect; + target->rrect = source->rrect; + target->windowid = source->windowid; +} + +//recenters the capture area to the mouse +//without exiting the display bounding box +static void rmdMoveCaptureArea( XRectangle *rect, + int cursor_x, + int cursor_y, + int width, + int height) { + int t_x = 0, t_y = 0; + + t_x = cursor_x - rect->width / 2; + t_x = (t_x >> 1) << 1; + rect->x = (t_x < 0) ? 0 : ((t_x + rect->width > width) ? width - rect->width : t_x); + t_y = cursor_y - rect->height / 2; + t_y = (t_y >> 1) << 1; + rect->y = (t_y < 0 ) ? 0 : ((t_y + rect->height > height) ? height - rect->height : t_y); +} + + +static void rmdBlocksReset(unsigned int blocks_w, unsigned int blocks_h) { + memset(yblocks, 0, blocks_w * blocks_h * sizeof(*yblocks)); + memset(ublocks, 0, blocks_w * blocks_h * sizeof(*ublocks)); + memset(vblocks, 0, blocks_w * blocks_h * sizeof(*vblocks)); +} + + +/** +* Extract cache blocks from damage list +* +* \param root Root entry of the list with damaged areas +* +* \param x_offset left x of the recording area +* +* \param y_offset upper y of the recording area +* +* \param blocks_w Width of image in blocks +* +* \param blocks_h Height of image in blocks +*/ +static void rmdBlocksFromList( RectArea **root, + unsigned int x_offset, + unsigned int y_offset, + unsigned int blocks_w, + unsigned int blocks_h) { + + rmdBlocksReset(blocks_w, blocks_h); + + for (RectArea *temp = *root; temp; temp = temp->next) { + int row_start, row_end, column_start, column_end; + + column_start = ((int)(temp->rect.x - x_offset)) / Y_UNIT_WIDTH; + column_end = ((int)(temp->rect.x + (temp->rect.width - 1) - x_offset)) / Y_UNIT_WIDTH; + row_start = ((int)(temp->rect.y - y_offset)) / Y_UNIT_WIDTH; + row_end = ((int)(temp->rect.y + (temp->rect.height - 1) - y_offset)) / Y_UNIT_WIDTH; + + for (int i = row_start; i < row_end + 1; i++) { + for (int j = column_start; j < column_end + 1; j++) { + + int blockno = i * blocks_w + j; + + yblocks[blockno] = 1; + ublocks[blockno] = 1; + vblocks[blockno] = 1; + } + } + } +} + +void *rmdGetFrame(ProgData *pdata) { + int blocks_w = pdata->enc_data->yuv.y_width / Y_UNIT_WIDTH, + blocks_h = pdata->enc_data->yuv.y_height / Y_UNIT_WIDTH; + unsigned int msk_ret; + XRectangle mouse_pos_abs, mouse_pos_rel, mouse_pos_temp; + BRWindow temp_brwin; + Window root_ret, child_ret; //Frame + XFixesCursorImage *xcim = NULL; + Image image = {}, image_back = {}; //the image that holds + //the current full screenshot + int init_img1 = 0, init_img2 = 0, img_sel, d_buff; + + img_sel = d_buff = pdata->args.full_shots; + + if ((init_img1 = rmdFirstFrame(pdata, &image) != 0)) { + if (pdata->args.encOnTheFly) { + if (remove(pdata->args.filename)) { + perror("Error while removing file:\n"); + } else { + fprintf(stderr, "SIGABRT received, file %s removed\n", + pdata->args.filename); + } + } else { + rmdPurgeCache(pdata->cache_data, !pdata->args.nosound); + } + + exit(init_img1); + } + + if (d_buff) { + if ((init_img2 = rmdFirstFrame(pdata, &image_back) != 0)) { + if (pdata->args.encOnTheFly) { + if (remove(pdata->args.filename)) { + perror("Error while removing file:\n"); + } else{ + fprintf(stderr, "SIGABRT received, file %s removed\n", + pdata->args.filename); + } + } else { + rmdPurgeCache(pdata->cache_data, !pdata->args.nosound); + } + + exit(init_img2); + } + } + + if (!pdata->args.noframe) { + pdata->shaped_w = rmdFrameInit( pdata->dpy, + pdata->specs.screen, + pdata->specs.root, + pdata->brwin.rrect.x, + pdata->brwin.rrect.y, + pdata->brwin.rrect.width, + pdata->brwin.rrect.height); + + XSelectInput(pdata->dpy, pdata->shaped_w, ExposureMask); + } + + mouse_pos_abs.x = mouse_pos_temp.x = 0; + mouse_pos_abs.y = mouse_pos_temp.y = 0; + mouse_pos_abs.width = mouse_pos_temp.width = pdata->dummy_p_size; + mouse_pos_abs.height = mouse_pos_temp.height = pdata->dummy_p_size; + + //This is the the place where we call XSelectInput + //and arrange so that we listen for damage on all + //windows + rmdInitEventsPolling(pdata); + + while (pdata->running) { + unsigned time_frameno; + + //if we are left behind we must not wait. + //also before actually pausing we must make sure the streams + //are synced. sound stops so this should only happen quickly. + pthread_mutex_lock(&pdata->time_mutex); + while ( (pdata->avd > 0 || pdata->args.nosound) && + pdata->capture_frameno >= pdata->time_frameno) + pthread_cond_wait(&pdata->time_cond, &pdata->time_mutex); + + time_frameno = pdata->time_frameno; + pthread_mutex_unlock(&pdata->time_mutex); + + //read all events and construct list with damage + //events (if not full_shots) + rmdEventLoop(pdata); + + if (pdata->paused) + continue; + + //switch back and front buffers (full_shots only) + if (d_buff) + img_sel = img_sel ? 0 : 1; + + rmdBRWinCpy(&temp_brwin, &pdata->brwin); + + + if ( pdata->args.xfixes_cursor || + pdata->args.have_dummy_cursor || + pdata->args.follow_mouse) { + + + // Pointer sequence: + // * Mark previous position as dirty with rmdRectInsert() + // * Update to new position + // * Mark new position as dirty with rmdRectInsert() + if ( !pdata->args.full_shots && + mouse_pos_temp.x >= 0 && + mouse_pos_temp.y >= 0 && + mouse_pos_temp.width > 0 && + mouse_pos_temp.height > 0) { + rmdRectInsert(&pdata->rect_root, &mouse_pos_temp); + } + + if (pdata->args.xfixes_cursor) { + xcim = XFixesGetCursorImage(pdata->dpy); + mouse_pos_abs.x = xcim->x - xcim->xhot; + mouse_pos_abs.y = xcim->y - xcim->yhot; + mouse_pos_abs.width = xcim->width; + mouse_pos_abs.height = xcim->height; + } else { + XQueryPointer( pdata->dpy, + pdata->specs.root, + &root_ret, &child_ret, + (int *)&mouse_pos_abs.x, + (int *)&mouse_pos_abs.y, + (int *)&mouse_pos_rel.x, + (int *)&mouse_pos_rel.y, + &msk_ret); + } + + clip_dummy_pointer_area(&mouse_pos_abs, &temp_brwin.rrect, &mouse_pos_temp); + if ( mouse_pos_temp.x >= 0 && + mouse_pos_temp.y >= 0 && + mouse_pos_temp.width > 0 && + mouse_pos_temp.height > 0) { + + //there are 3 capture scenarios: + // * Xdamage + // * full-shots with double buffering + // * full-shots on a single buffer + //The last one cannot be reached through + //this code (see above how the d_buf variable is set), but + //even if it could, it would not be of interest regarding the + //marking of the cursor area. Single buffer means full repaint + //on every frame so there is no need for marking at all. + + if (!pdata->args.full_shots) { + rmdRectInsert(&pdata->rect_root, &mouse_pos_temp); + } else if (d_buff) { + unsigned char *back_buff= img_sel ? + ((unsigned char*)image.ximage->data) : + ((unsigned char*)image_back.ximage->data); + + mark_buffer_area( + back_buff, + mouse_pos_temp.x - temp_brwin.rrect.x, + mouse_pos_temp.y - temp_brwin.rrect.y, + mouse_pos_temp.width, mouse_pos_temp.height, temp_brwin.rrect.width, + pdata->specs.depth + ); + } + } + } + + if (pdata->args.follow_mouse) { + rmdMoveCaptureArea( &pdata->brwin.rrect, + mouse_pos_abs.x + pdata->args.xfixes_cursor ? xcim->xhot : 0, + mouse_pos_abs.y + pdata->args.xfixes_cursor ? xcim->yhot : 0, + pdata->specs.width, + pdata->specs.height); + + if (!pdata->args.noframe) + rmdMoveFrame( pdata->dpy, + pdata->shaped_w, + temp_brwin.rrect.x, + temp_brwin.rrect.y); + } + + if (!pdata->args.full_shots) { + pthread_mutex_lock(&pdata->yuv_mutex); + rmdUpdateImage( pdata->dpy, + &pdata->enc_data->yuv, + &pdata->specs, + &pdata->rect_root, + &temp_brwin, + pdata->enc_data, + &image, + pdata->args.noshared, + pdata->shm_opcode, + pdata->args.no_quick_subsample); + + rmdBlocksFromList( &pdata->rect_root, + temp_brwin.rrect.x, + temp_brwin.rrect.y, + blocks_w, + blocks_h); + + pthread_mutex_unlock(&pdata->yuv_mutex); + } else { + unsigned char *front_buff = !img_sel ? ((unsigned char*)image.ximage->data): + ((unsigned char*)image_back.ximage->data); + unsigned char *back_buff = !d_buff ? NULL : (img_sel ? + ((unsigned char*)image.ximage->data): + ((unsigned char*)image_back.ximage->data)); + + if (pdata->args.noshared) { + rmdGetZPixmap( pdata->dpy, + pdata->specs.root, + image.ximage->data, + temp_brwin.rrect.x, + temp_brwin.rrect.y, + temp_brwin.rrect.width, + temp_brwin.rrect.height); + } else { + XShmGetImage( pdata->dpy, + pdata->specs.root, + ((!img_sel) ? image.ximage : image_back.ximage), + temp_brwin.rrect.x, + temp_brwin.rrect.y, + AllPlanes); + } + + pthread_mutex_lock(&pdata->yuv_mutex); + rmdBlocksReset(blocks_w, blocks_h); + rmdUpdateYuvBuffer( &pdata->enc_data->yuv, + front_buff, + back_buff, + 0, + 0, + temp_brwin.rrect.width, + temp_brwin.rrect.height, + pdata->args.no_quick_subsample, + pdata->specs.depth); + + pthread_mutex_unlock(&pdata->yuv_mutex); + } + + if (pdata->args.xfixes_cursor || pdata->args.have_dummy_cursor) { + int mouse_xoffset, mouse_yoffset; + + //avoid segfaults + clip_dummy_pointer_area(&mouse_pos_abs, &temp_brwin.rrect, &mouse_pos_temp); + mouse_xoffset = mouse_pos_temp.x - mouse_pos_abs.x; + mouse_yoffset = mouse_pos_temp.y - mouse_pos_abs.y; + + if ((mouse_xoffset < 0) || (mouse_xoffset > mouse_pos_abs.width)) + mouse_xoffset = 0; + + if ((mouse_yoffset < 0) || (mouse_yoffset > mouse_pos_abs.height)) + mouse_yoffset = 0; + + //draw the cursor + if ( (mouse_pos_temp.x >= 0) && + (mouse_pos_temp.y >= 0) && + (mouse_pos_temp.width > 0) && + (mouse_pos_temp.height > 0)) { + + if (pdata->args.xfixes_cursor) { + rmdXFixesPointerToYuv( + &pdata->enc_data->yuv, + ((unsigned char*)xcim->pixels), + mouse_pos_temp.x - temp_brwin.rrect.x, + mouse_pos_temp.y - temp_brwin.rrect.y, + mouse_pos_temp.width, + mouse_pos_temp.height, + mouse_xoffset, + mouse_yoffset, + xcim->width-mouse_pos_temp.width + ); + } else { + rmdDummyPointerToYuv( + &pdata->enc_data->yuv, + pdata->dummy_pointer, + mouse_pos_temp.x - temp_brwin.rrect.x, + mouse_pos_temp.y - temp_brwin.rrect.y, + mouse_pos_temp.width, + mouse_pos_temp.height, + mouse_xoffset, + mouse_yoffset, + pdata->npxl + ); + } + + if (d_buff) { + //make previous cursor position dirty + //on the currently front buffer (which + //will be the back buffer next time it's + //used) + unsigned char *front_buff = !img_sel ? + ((unsigned char*)image.ximage->data) : + ((unsigned char*)image_back.ximage->data); + + mark_buffer_area( + front_buff, + mouse_pos_temp.x - temp_brwin.rrect.x, + mouse_pos_temp.y - temp_brwin.rrect.y, + mouse_pos_temp.width, + mouse_pos_temp.height, + temp_brwin.rrect.width, + pdata->specs.depth + ); + } + + } + + if (pdata->args.xfixes_cursor) { + XFree(xcim); + xcim = NULL; + } + } + + if (!pdata->args.full_shots) + rmdClearList(&pdata->rect_root); + + /* notify the encoder of the new frame */ + pthread_mutex_lock(&pdata->img_buff_ready_mutex); + pdata->capture_frameno = time_frameno; + pthread_cond_broadcast(&pdata->image_buffer_ready); + pthread_mutex_unlock(&pdata->img_buff_ready_mutex); + } + + if (!pdata->args.noframe) + XDestroyWindow(pdata->dpy, pdata->shaped_w); + + if (!pdata->args.noshared) { + XShmDetach(pdata->dpy, &image.shm_info); + shmdt(image.shm_info.shmaddr); + if (d_buff) { + XShmDetach(pdata->dpy, &image_back.shm_info); + shmdt(image_back.shm_info.shmaddr); + } + } + + pthread_exit(&errno); +} diff --git a/src/rmd_get_frame.h b/src/rmd_get_frame.h new file mode 100644 index 0000000..162c05e --- /dev/null +++ b/src/rmd_get_frame.h @@ -0,0 +1,41 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef GET_FRAME_H +#define GET_FRAME_H 1 + +#include "rmd_types.h" + + +/** +* Retrieve frame form xserver, and transform to a yuv buffer, +* either directly(full shots) or by calling UpdateImage. +* \param pdata ProgData struct containing all program data +*/ +void *rmdGetFrame(ProgData *pdata); + + +#endif diff --git a/src/rmd_getzpixmap.c b/src/rmd_getzpixmap.c new file mode 100644 index 0000000..43465c8 --- /dev/null +++ b/src/rmd_getzpixmap.c @@ -0,0 +1,117 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_getzpixmap.h" + +#include "rmd_types.h" + + +#include <X11/Xlib.h> +#include <X11/Xlibint.h> +#include <X11/extensions/shmproto.h> +#include <X11/extensions/XShm.h> + + + +int rmdGetZPixmap( Display *dpy, + Window root, + char *data, + int x, + int y, + int width, + int height) { + + xGetImageReply reply; + xGetImageReq *request; + long nbytes; + + LockDisplay(dpy); + GetReq(GetImage, request); + request->drawable = root; + request->x = x; + request->y = y; + request->width = width; + request->height = height; + request->planeMask = AllPlanes; + request->format = ZPixmap; + + if (!_XReply(dpy, (xReply *)&reply, 0, xFalse) || !reply.length) { + UnlockDisplay(dpy); + SyncHandle(); + + return 1; + } + + nbytes = (long)reply.length << 2; + _XReadPad(dpy, data, nbytes); + UnlockDisplay(dpy); + SyncHandle(); + + return 0; +} + +int rmdGetZPixmapSHM( Display *dpy, + Window root, + XShmSegmentInfo *shminfo, + int shm_opcode, + char *data, + int x, + int y, + int width, + int height) { + + xShmGetImageReply reply; + xShmGetImageReq *request = NULL; + + LockDisplay(dpy); + GetReq(ShmGetImage, request); + + request->reqType = shm_opcode; + request->shmReqType = X_ShmGetImage; + request->shmseg = shminfo->shmseg; + + request->drawable = root; + request->x = x; + request->y = y; + request->width = width; + request->height = height; + request->planeMask = AllPlanes; + request->format = ZPixmap; + request->offset = data - shminfo->shmaddr; + + if ((!_XReply(dpy, (xReply *)&reply, 0, xFalse)) || !reply.length) { + UnlockDisplay(dpy); + SyncHandle(); + + return 1; + } + + UnlockDisplay(dpy); + SyncHandle(); + + return 0; +} diff --git a/src/rmd_getzpixmap.h b/src/rmd_getzpixmap.h new file mode 100644 index 0000000..87ad7bb --- /dev/null +++ b/src/rmd_getzpixmap.h @@ -0,0 +1,99 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef GETZPIXMAP_H +#define GETZPIXMAP_H 1 + +#include "rmd_types.h" + +#include <X11/extensions/XShm.h> + +/** +* Rerieve pixmap data from xserver +* +* \param dpy Connection to the server +* +* \param root root window of the display +* +* \param data (preallocated)buffer to place the data +* +* \param x x position of the screenshot +* +* \param y y position of the screenshot +* +* \param x x position of the screenshot +* +* \param width width of the screenshot +* +* \param height height position of the screenshot +* +* \returns 0 on Success 1 on Failure +*/ +int rmdGetZPixmap(Display *dpy, + Window root, + char *data, + int x, + int y, + int width, + int height); + +/** +* Rerieve pixmap data from xserver through the MIT-Shm extension +* +* \param dpy Connection to the server +* +* \param root root window of the display +* +* \param shminfo Info for the shared memory segment +* +* \param shm_opcode Opcode of Shm extension +* +* \param data (preallocated)buffer to place the data +* +* \param x x position of the screenshot +* +* \param y y position of the screenshot +* +* \param x x position of the screenshot +* +* \param width width of the screenshot +* +* \param height height position of the screenshot +* +* \returns 0 on Success 1 on Failure +*/ +int rmdGetZPixmapSHM(Display *dpy, + Window root, + XShmSegmentInfo *shminfo, + int shm_opcode, + char *data, + int x, + int y, + int width, + int height); + + +#endif diff --git a/src/rmd_init_encoder.c b/src/rmd_init_encoder.c new file mode 100644 index 0000000..a0d81e6 --- /dev/null +++ b/src/rmd_init_encoder.c @@ -0,0 +1,346 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_init_encoder.h" + +#include "rmd_types.h" + +#include "skeleton.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/stat.h> + + + +static void m_add_fishead_packet(ogg_stream_state *m_ogg_state) { + fishead_packet skel_fp; + + skel_fp.ptime_n = skel_fp.btime_n = 0; + skel_fp.ptime_d = skel_fp.btime_d = 1000; + + add_fishead_to_stream(m_ogg_state, &skel_fp); +} + + +static int rmdIncrementalNaming(char **name) { + struct stat buff; + char *base_name__; + int i = 0, fname_length = strlen(*name)-4; + + base_name__ = malloc(fname_length+1); + strncpy(base_name__, *name, fname_length); + base_name__[fname_length] = '\0'; + + //this will go on an endless loop if you have 65536? + //files with the same name + //or it will crash and die.anyone interested in trying ? + while (stat(*name, &buff)==0) { + //create new name + char *tname = malloc(strlen(*name)+10); + char numbuf[8]; + + strcpy(tname, base_name__); + strcat(tname, "-"); + i++; + snprintf( numbuf, 8, "%d", i ); + strcat(tname, numbuf); + strcat(tname, ".ogv"); + //save new name + + free(*name); + *name = malloc(strlen(tname)+1); + strcpy(*name, tname); + free(tname); + } + + free(base_name__); + return 0; +} + +void rmdInitEncoder(ProgData *pdata, EncData *enc_data_t, int buffer_ready) { + int y0, y1, y2, fname_length; + ogg_stream_state m_ogg_skel; + ogg_page skel_og_pg; + fisbone_packet skel_fbv, //video fisbone packet + skel_fba; //audio fisbone packet + const char *fname; + + pdata->enc_data = enc_data_t; + + fname = pdata->args.filename; + fname_length = strlen(fname); + if (!(fname_length>4 && !strcasecmp(&fname[fname_length-3], "ogv"))) { + + char *new_name = malloc(fname_length + 5); + strcpy(new_name, fname); + strcat(new_name, ".ogv"); + + free(pdata->args.filename); + pdata->args.filename = new_name; + } + + if (!pdata->args.overwrite) { + rmdIncrementalNaming(&(pdata)->args.filename); + fprintf(stderr, "Output file: %s\n", pdata->args.filename); + } + + enc_data_t->fp = fopen((pdata)->args.filename, "w"); + if (enc_data_t->fp == NULL) { + fprintf(stderr, "Cannot open file %s for writting!\n", (pdata)->args.filename); + exit(13); + } + + //each stream must have a unique + srand(time(NULL)); + y0 = rand() + 1; + y1 = rand() + 1; + y2 = rand() + 1; + y2 += (y1 == y2); + y0 = (((y0 == y1) || (y0 == y2)) ? (y1 + y2) : y0); + + //init ogg streams + //skeleton first + ogg_stream_init(&m_ogg_skel, y0); + m_add_fishead_packet(&m_ogg_skel); + if (ogg_stream_pageout(&m_ogg_skel, &skel_og_pg) != 1) { + fprintf (stderr, "Internal Ogg library error.\n"); + exit (2); + } + fwrite(skel_og_pg.header, 1, skel_og_pg.header_len, enc_data_t->fp); + fwrite(skel_og_pg.body, 1, skel_og_pg.body_len, enc_data_t->fp); + + ogg_stream_init(&enc_data_t->m_ogg_ts, y1); + if (!pdata->args.nosound) + ogg_stream_init(&enc_data_t->m_ogg_vs, y2); + + theora_info_init(&enc_data_t->m_th_inf); + enc_data_t->m_th_inf.frame_width = pdata->brwin.rrect.width; + enc_data_t->m_th_inf.frame_height = pdata->brwin.rrect.height; + enc_data_t->m_th_inf.width = ((enc_data_t->m_th_inf.frame_width + 15) >> 4) << 4; + enc_data_t->m_th_inf.height = ((enc_data_t->m_th_inf.frame_height + 15) >> 4) << 4; + enc_data_t->m_th_inf.offset_x = 0; + enc_data_t->m_th_inf.offset_y = 0; + + enc_data_t->m_th_inf.fps_numerator = pdata->args.fps * 100.0; + enc_data_t->m_th_inf.fps_denominator = 100; + enc_data_t->m_th_inf.aspect_numerator = 1; + enc_data_t->m_th_inf.aspect_denominator = 1; + + enc_data_t->m_th_inf.colorspace = OC_CS_UNSPECIFIED; + enc_data_t->m_th_inf.pixelformat = OC_PF_420; + + enc_data_t->m_th_inf.target_bitrate = pdata->args.v_bitrate; + enc_data_t->m_th_inf.quality = pdata->args.v_quality; + enc_data_t->m_th_inf.dropframes_p = 0; + enc_data_t->m_th_inf.quick_p = 1; + enc_data_t->m_th_inf.keyframe_auto_p = 1; + enc_data_t->m_th_inf.keyframe_frequency = 64; + enc_data_t->m_th_inf.keyframe_frequency_force = 64; + enc_data_t->m_th_inf.keyframe_data_target_bitrate = enc_data_t->m_th_inf.quality * 1.5; + enc_data_t->m_th_inf.keyframe_auto_threshold = 80; + enc_data_t->m_th_inf.keyframe_mindistance = 8; + enc_data_t->m_th_inf.noise_sensitivity = 1; + enc_data_t->m_th_inf.sharpness = 2; + + if (!pdata->args.nosound) { + int ret; + vorbis_info_init(&enc_data_t->m_vo_inf); + ret = vorbis_encode_init_vbr( &enc_data_t->m_vo_inf, + pdata->args.channels, + pdata->args.frequency, + (float)pdata->args.s_quality*0.1); + if (ret) { + fprintf(stderr, "Error while setting up vorbis stream quality!\n"); + exit(2); + } + vorbis_comment_init(&enc_data_t->m_vo_cmmnt); + vorbis_analysis_init(&enc_data_t->m_vo_dsp, &enc_data_t->m_vo_inf); + vorbis_block_init(&enc_data_t->m_vo_dsp, &enc_data_t->m_vo_block); + } + + if (theora_encode_init(&enc_data_t->m_th_st, &enc_data_t->m_th_inf)) { + fprintf(stderr, "Theora encoder initialization failure.\n"); + exit(2); + } + + if (theora_encode_header(&enc_data_t->m_th_st, &enc_data_t->m_ogg_pckt1)) { + fprintf(stderr, "Theora enocde header failure.\n"); + exit(2); + } + + ogg_stream_packetin(&enc_data_t->m_ogg_ts, &enc_data_t->m_ogg_pckt1); + if (ogg_stream_pageout(&enc_data_t->m_ogg_ts, &enc_data_t->m_ogg_pg) != 1) { + fprintf(stderr, "Internal Ogg library error.\n"); + exit(2); + } + fwrite(enc_data_t->m_ogg_pg.header, 1, + enc_data_t->m_ogg_pg.header_len, + enc_data_t->fp); + fwrite(enc_data_t->m_ogg_pg.body, 1, + enc_data_t->m_ogg_pg.body_len, + enc_data_t->fp); + + theora_comment_init(&enc_data_t->m_th_cmmnt); + theora_comment_add_tag(&enc_data_t->m_th_cmmnt, "recordMyDesktop", VERSION); + theora_encode_comment(&enc_data_t->m_th_cmmnt, &enc_data_t->m_ogg_pckt1); + ogg_stream_packetin(&enc_data_t->m_ogg_ts, &enc_data_t->m_ogg_pckt1); + theora_encode_tables(&enc_data_t->m_th_st, &enc_data_t->m_ogg_pckt1); + ogg_stream_packetin(&enc_data_t->m_ogg_ts, &enc_data_t->m_ogg_pckt1); + + if (!pdata->args.nosound) { + ogg_packet header; + ogg_packet header_comm; + ogg_packet header_code; + + vorbis_analysis_headerout( &enc_data_t->m_vo_dsp, + &enc_data_t->m_vo_cmmnt, + &header, &header_comm, + &header_code); + ogg_stream_packetin(&enc_data_t->m_ogg_vs, &header); + if (ogg_stream_pageout(&enc_data_t->m_ogg_vs, &enc_data_t->m_ogg_pg) != 1) { + fprintf(stderr, "Internal Ogg library error.\n"); + exit(2); + } + + fwrite(enc_data_t->m_ogg_pg.header, 1, + enc_data_t->m_ogg_pg.header_len, + enc_data_t->fp); + + fwrite(enc_data_t->m_ogg_pg.body, 1, + enc_data_t->m_ogg_pg.body_len, + enc_data_t->fp); + + ogg_stream_packetin(&enc_data_t->m_ogg_vs, &header_comm); + ogg_stream_packetin(&enc_data_t->m_ogg_vs, &header_code); + } + + //fishbone packets go here + memset(&skel_fbv, 0, sizeof(skel_fbv)); + skel_fbv.serial_no = enc_data_t->m_ogg_ts.serialno; + skel_fbv.nr_header_packet = 3; + skel_fbv.granule_rate_n = enc_data_t->m_th_inf.fps_numerator; + skel_fbv.granule_rate_d = enc_data_t->m_th_inf.fps_denominator; + skel_fbv.start_granule = 0; + skel_fbv.preroll = 0; + skel_fbv.granule_shift = theora_granule_shift(&enc_data_t->m_th_inf); + add_message_header_field(&skel_fbv, "Content-Type", "video/theora"); + + add_fisbone_to_stream(&m_ogg_skel, &skel_fbv); + + if (!pdata->args.nosound) { + + memset(&skel_fba, 0, sizeof(skel_fba)); + skel_fba.serial_no = enc_data_t->m_ogg_vs.serialno; + skel_fba.nr_header_packet = 3; + skel_fba.granule_rate_n = pdata->args.frequency; + skel_fba.granule_rate_d = (ogg_int64_t)1; + skel_fba.start_granule = 0; + skel_fba.preroll = 2; + skel_fba.granule_shift = 0; + add_message_header_field(&skel_fba, "Content-Type", "audio/vorbis"); + + add_fisbone_to_stream(&m_ogg_skel, &skel_fba); + } + + while (1) { + int result = ogg_stream_flush(&m_ogg_skel, &skel_og_pg); + if (result < 0) { + fprintf (stderr, "Internal Ogg library error.\n"); + exit(2); + } + + if (result == 0) + break; + + fwrite(skel_og_pg.header, 1, skel_og_pg.header_len, enc_data_t->fp); + fwrite(skel_og_pg.body, 1, skel_og_pg.body_len, enc_data_t->fp); + } + + while (1) { + int result = ogg_stream_flush(&enc_data_t->m_ogg_ts, &enc_data_t->m_ogg_pg); + if (result < 0) { + fprintf(stderr, "Internal Ogg library error.\n"); + exit(2); + } + + if (result == 0) + break; + + fwrite( enc_data_t->m_ogg_pg.header, 1, + enc_data_t->m_ogg_pg.header_len, + enc_data_t->fp); + fwrite( enc_data_t->m_ogg_pg.body, 1, + enc_data_t->m_ogg_pg.body_len, + enc_data_t->fp); + } + + if (!pdata->args.nosound) { + while (1) { + int result = ogg_stream_flush(&enc_data_t->m_ogg_vs, &enc_data_t->m_ogg_pg); + if (result < 0) { + fprintf(stderr, "Internal Ogg library error.\n"); + exit(2); + } + + if (result == 0) + break; + + fwrite( enc_data_t->m_ogg_pg.header, 1, + enc_data_t->m_ogg_pg.header_len, + enc_data_t->fp); + fwrite( enc_data_t->m_ogg_pg.body, 1, + enc_data_t->m_ogg_pg.body_len, + enc_data_t->fp); + } + } + + //skeleton eos + add_eos_packet_to_stream(&m_ogg_skel); + if (ogg_stream_flush(&m_ogg_skel, &skel_og_pg) < 0) { + fprintf(stderr, "Internal Ogg library error.\n"); + exit(2); + } + fwrite(skel_og_pg.header, 1, skel_og_pg.header_len, enc_data_t->fp); + + //theora buffer allocation, if any + if (!buffer_ready) { + enc_data_t->yuv.y = malloc(enc_data_t->m_th_inf.height * enc_data_t->m_th_inf.width); + enc_data_t->yuv.u = malloc(enc_data_t->m_th_inf.height * enc_data_t->m_th_inf.width / 4); + enc_data_t->yuv.v = malloc(enc_data_t->m_th_inf.height * enc_data_t->m_th_inf.width / 4); + enc_data_t->yuv.y_width = enc_data_t->m_th_inf.width; + enc_data_t->yuv.y_height = enc_data_t->m_th_inf.height; + enc_data_t->yuv.y_stride = enc_data_t->m_th_inf.width; + + enc_data_t->yuv.uv_width = enc_data_t->m_th_inf.width / 2; + enc_data_t->yuv.uv_height = enc_data_t->m_th_inf.height / 2; + enc_data_t->yuv.uv_stride = enc_data_t->m_th_inf.width / 2; + } + + theora_info_clear(&enc_data_t->m_th_inf); +} diff --git a/src/rmd_init_encoder.h b/src/rmd_init_encoder.h new file mode 100644 index 0000000..bbf73c7 --- /dev/null +++ b/src/rmd_init_encoder.h @@ -0,0 +1,47 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef INIT_ENCODER_H +#define INIT_ENCODER_H 1 + +#include "rmd_types.h" + + +/** +* Initialize theora,vorbis encoders, and their respective ogg streams. +* +* \param pdata ProgData struct containing all program data +* +* \param enc_data_t Encoding options +* +* \param buffer_ready when 1, the yuv buffer must be preallocated +* when 0 rmdInitEncoder will alocate a new one +* +*/ +void rmdInitEncoder(ProgData *pdata,EncData *enc_data_t,int buffer_ready); + + +#endif diff --git a/src/rmd_initialize_data.c b/src/rmd_initialize_data.c new file mode 100644 index 0000000..0f0a073 --- /dev/null +++ b/src/rmd_initialize_data.c @@ -0,0 +1,252 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_initialize_data.h" + +#include "rmd_cache.h" +#include "rmd_init_encoder.h" +#include "rmd_jack.h" +#include "rmd_make_dummy_pointer.h" +#include "rmd_opendev.h" +#include "rmd_yuv_utils.h" +#include "rmd_types.h" + +#include <pthread.h> + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +#ifdef HAVE_LIBASOUND +static void rmdFixBufferSize(snd_pcm_uframes_t *buffsize) { + snd_pcm_uframes_t buffsize_t = *buffsize, +#else +static void rmdFixBufferSize(u_int32_t *buffsize) { + u_int32_t buffsize_t = *buffsize, +#endif + buffsize_ret = 1; + + while (buffsize_t > 1) { + buffsize_t >>= 1; + buffsize_ret <<= 1; + } + fprintf(stderr, "Buffer size adjusted to %d from %d frames.\n", + (int)buffsize_ret, (int)*buffsize); +} + +int rmdInitializeData(ProgData *pdata, EncData *enc_data, CacheData *cache_data) { + fprintf(stderr, "Initializing...\n"); + + rmdMakeMatrices(); + if (pdata->args.have_dummy_cursor) { + pdata->dummy_pointer = rmdMakeDummyPointer( pdata->dpy, + &pdata->specs, + 16, + pdata->args.cursor_color, + 0, + &pdata->npxl); + pdata->dummy_p_size = 16; + } else + pdata->dummy_p_size = 0; + + pthread_mutex_init(&pdata->sound_buffer_mutex, NULL); + pthread_mutex_init(&pdata->img_buff_ready_mutex, NULL); + pthread_mutex_init(&pdata->theora_lib_mutex, NULL); + pthread_mutex_init(&pdata->vorbis_lib_mutex, NULL); + pthread_mutex_init(&pdata->libogg_mutex, NULL); + pthread_mutex_init(&pdata->yuv_mutex, NULL); + pthread_mutex_init(&pdata->pause_mutex, NULL); + pthread_mutex_init(&pdata->time_mutex, NULL); + pthread_cond_init(&pdata->time_cond, NULL); + pthread_cond_init(&pdata->pause_cond, NULL); + pthread_cond_init(&pdata->image_buffer_ready, NULL); + pthread_cond_init(&pdata->sound_data_read, NULL); + pthread_cond_init(&pdata->theora_lib_clean, NULL); + pthread_cond_init(&pdata->vorbis_lib_clean, NULL); + + pdata->th_encoding_clean = pdata->v_encoding_clean = 1; + pdata->rect_root = NULL; + pdata->avd = 0; + pdata->sound_buffer = NULL; + pdata->running = TRUE; + pdata->paused = FALSE; + pdata->aborted = FALSE; + pdata->pause_state_changed = FALSE; + pdata->frames_total = 0; + pdata->frames_lost = 0; + pdata->capture_frameno = 0; + pdata->time_frameno = 0; + + if (!pdata->args.nosound) { + if (!pdata->args.use_jack) { + rmdFixBufferSize(&pdata->args.buffsize); +#ifdef HAVE_LIBASOUND + pdata->sound_handle=rmdOpenDev( pdata->args.device, + &pdata->args.channels, + &pdata->args.frequency, + &pdata->args.buffsize, + &pdata->periodsize, + &pdata->periodtime, + &pdata->hard_pause); + + pdata->sound_framesize=(snd_pcm_format_width(SND_PCM_FORMAT_S16_LE) / 8 * + pdata->args.channels); + + if (pdata->sound_handle == NULL) { +#else + pdata->sound_handle = rmdOpenDev( pdata->args.device, + pdata->args.channels, + pdata->args.frequency); + + pdata->periodtime = (1000000 * pdata->args.buffsize) / + ((pdata->args.channels<<1) * pdata->args.frequency); + //when using OSS periodsize serves as an alias of buffsize + pdata->periodsize = pdata->args.buffsize; + pdata->sound_framesize = pdata->args.channels<<1; + if (pdata->sound_handle<0) { +#endif + fprintf(stderr, "Error while opening/configuring soundcard %s\n" + "Try running with the --no-sound or specify a " + "correct device.\n", + pdata->args.device); + return 3; + } + } else { +#ifdef HAVE_LIBJACK + int jack_error = 0; + pdata->jdata->port_names = pdata->args.jack_port_names; + pdata->jdata->nports = pdata->args.jack_nports; + pdata->jdata->ringbuffer_secs = pdata->args.jack_ringbuffer_secs; + pdata->jdata->sound_buffer_mutex = &pdata->sound_buffer_mutex; + pdata->jdata->sound_data_read = &pdata->sound_data_read; + pdata->jdata->capture_started = 0; + + if ((jack_error = rmdStartJackClient(pdata->jdata))!=0) + return jack_error; + + pdata->args.buffsize = pdata->jdata->buffersize; + pdata->periodsize = pdata->args.buffsize; + pdata->args.frequency = pdata->jdata->frequency; + pdata->args.channels = pdata->jdata->nports; + pdata->periodtime = 1000000 * pdata->args.buffsize / + pdata->args.frequency; + pdata->sound_framesize = sizeof(jack_default_audio_sample_t) * + pdata->jdata->nports; +#else + fprintf(stderr, "Should not be here!\n"); + exit(-1); +#endif + } + } + + if (pdata->args.encOnTheFly) + rmdInitEncoder(pdata, enc_data, 0); + else + rmdInitCacheData(pdata, enc_data, cache_data); + + for (int i = 0; i < pdata->enc_data->yuv.y_width * pdata->enc_data->yuv.y_height; i++) + pdata->enc_data->yuv.y[i] = 0; + + for (int i = 0; i < pdata->enc_data->yuv.uv_width * pdata->enc_data->yuv.uv_height; i++) + pdata->enc_data->yuv.v[i] = pdata->enc_data->yuv.u[i] = 127; + + yblocks = malloc((pdata->enc_data->yuv.y_width / Y_UNIT_WIDTH) * + (pdata->enc_data->yuv.y_height / Y_UNIT_WIDTH)); + ublocks = malloc((pdata->enc_data->yuv.y_width / Y_UNIT_WIDTH) * + (pdata->enc_data->yuv.y_height / Y_UNIT_WIDTH)); + vblocks = malloc((pdata->enc_data->yuv.y_width / Y_UNIT_WIDTH) * + (pdata->enc_data->yuv.y_height / Y_UNIT_WIDTH)); + + pdata->frametime = 1000000 / pdata->args.fps; + + return 0; + +} + +void rmdSetupDefaultArgs(ProgArgs *args) { + args->delay = 0; + args->windowid = 0; + args->x = 0; + args->y = 0; + args->width = 0; + args->height = 0; + args->rescue_path = NULL; + args->nosound = 0; + args->full_shots = 0; + args->follow_mouse = 0; + args->encOnTheFly = 0; + args->nowmcheck = 0; + args->overwrite = 0; + args->use_jack = 0; + args->noshared = 0; + args->no_encode = 0; + args->noframe = 0; + args->jack_nports = 0; + args->jack_ringbuffer_secs = 3.0; + args->zerocompression = 1; + args->no_quick_subsample = 1; + args->cursor_color = 1; + args->have_dummy_cursor = 0; + args->xfixes_cursor = 1; + args->fps = 15; + args->channels = 1; + args->frequency = 22050; + args->buffsize = 4096; + args->v_bitrate = 0; + args->v_quality = 63; + args->s_quality = 10; + + if (getenv("DISPLAY") != NULL) { + args->display = malloc(strlen(getenv("DISPLAY")) + 1); + strcpy(args->display, getenv("DISPLAY")); + } else { + args->display = NULL; + } + + memset(args->jack_port_names, 0, sizeof(args->jack_port_names)); + + args->device = malloc(strlen(DEFAULT_AUDIO_DEVICE) + 1); + strcpy(args->device, DEFAULT_AUDIO_DEVICE); + + args->workdir = malloc(5); + strcpy(args->workdir, "/tmp"); + + args->pause_shortcut = malloc(15); + strcpy(args->pause_shortcut, "Control+Mod1+p"); + + args->stop_shortcut = malloc(15); + strcpy(args->stop_shortcut, "Control+Mod1+s"); + + args->filename = malloc(8); + strcpy(args->filename, "out.ogv"); +} + +void rmdCleanUp(void) { + free(yblocks); + free(ublocks); + free(vblocks); +} diff --git a/src/rmd_initialize_data.h b/src/rmd_initialize_data.h new file mode 100644 index 0000000..a5e43dd --- /dev/null +++ b/src/rmd_initialize_data.h @@ -0,0 +1,62 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef INITIALIZE_DATA_H +#define INITIALIZE_DATA_H 1 + +#include "rmd_types.h" + + +/** +* initialize lists,mutexes,image buffers, take first screenshot, +* and anything else needed before launching the capture threads. +* +* \param pdata ProgData struct containing all program data +* +* \param enc_data reference to enc_data structure +* +* \param cache_data reference to cache_data structure +* +* \returns 0 on success, other values must cause the program to exit +*/ +int rmdInitializeData(ProgData *pdata, + EncData *enc_data, + CacheData *cache_data); + +/** +* Sets up the ProgArgs structure to default values. +*/ +void rmdSetupDefaultArgs(ProgArgs *args); + +/** +* Currently only frees some memory +* (y,u,v blocks) +* +*/ +void rmdCleanUp(void); + + +#endif diff --git a/src/rmd_jack.c b/src/rmd_jack.c new file mode 100644 index 0000000..841017f --- /dev/null +++ b/src/rmd_jack.c @@ -0,0 +1,209 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_jack.h" + +#include "rmd_types.h" + +#include <pthread.h> + +#include <string.h> + +#ifdef HAVE_LIBJACK + + +/** +* Callback for capture through jack +* +* \param nframes Number of frames captured +* +* \param jdata_t Pointer to JackData struct containing port +* and client information +* +* \returns Zero always +*/ +static int rmdJackCapture(jack_nframes_t nframes, void *jdata_t) { + JackData *jdata = (JackData *)jdata_t; + + if (!jdata->pdata->running || jdata->pdata->paused || !jdata->capture_started) + return 0; + + for(int i = 0; i < jdata->nports; i++) + jdata->portbuf[i] = jack_port_get_buffer(jdata->ports[i], nframes); + + + pthread_mutex_lock(jdata->sound_buffer_mutex); +//vorbis analysis buffer wants uninterleaved data +//so we are simply placing the buffers for every channel +//sequentially on the ringbuffer + for(int i = 0; i < jdata->nports; i++) + jack_ringbuffer_write( jdata->sound_buffer, + (void *)(jdata->portbuf[i]), + nframes * + sizeof(jack_default_audio_sample_t)); + + pthread_cond_signal(jdata->sound_data_read); + pthread_mutex_unlock(jdata->sound_buffer_mutex); + + return 0; +} + +/** +* Register and Activate specified ports +* +* \param jdata_t Pointer to JackData struct containing port +* and client information +* +* \returns 0 on Success, 1 on failure +*/ +static int rmdSetupPorts(JackData *jdata) { + jdata->ports = malloc(sizeof(jack_port_t *) * jdata->nports); + jdata->portbuf = malloc(sizeof(jack_default_audio_sample_t *) * jdata->nports); + memset(jdata->portbuf, 0, sizeof(jack_default_audio_sample_t *) * jdata->nports); + + for(int i = 0; i < jdata->nports; i++) { + char name[64];//recordMyDesktop:input_n<64 is enough for full name + char num[8]; + strcpy(name, "input_"); + snprintf(num, 8, "%d", i + 1); + strcat(name, num); + + jdata->ports[i] = jack_port_register( jdata->client, + name, + JACK_DEFAULT_AUDIO_TYPE, + JackPortIsInput, + 0); + + if (!jdata->ports[i]) { + fprintf(stderr, "Cannot register input port \"%s\"!\n", name); + return 1; + } + + if (jack_connect(jdata->client, jdata->port_names[i], jack_port_name(jdata->ports[i]))) { + + fprintf(stderr, "Cannot connect input port %s to %s\n", + jack_port_name(jdata->ports[i]), + jdata->port_names[i]); + return 1; + } + } + return 0; +} + +//in case the jack server shuts down +//the program should stop recording, +//encode the result(if not on the fly) +//an exit cleanly. +static void rmdJackShutdown(void *jdata_t) { + JackData *jdata = (JackData *)jdata_t; + + jdata->pdata->running = FALSE; + + fprintf (stderr, "JACK shutdown\n"); +} + +int rmdStartJackClient(JackData *jdata) { + float ring_buffer_size = 0.0; + int pid; + char pidbuf[8]; + char rmd_client_name[32]; + + //construct the jack client name + //which is recordMyDesktop-pid + //in order to allow multiple + //instances of recordMyDesktop + //to connetc to a Jack Server + strcpy(rmd_client_name, "recordMyDesktop-"); + pid = getpid(); + snprintf( pidbuf, 8, "%d", pid ); + strcat(rmd_client_name, pidbuf); + + if ((jdata->client = jack_client_new(rmd_client_name)) == 0) { + fprintf(stderr, "Could not create new client!\n" + "Make sure that Jack server is running!\n"); + return 15; + } +//in contrast to ALSA and OSS, Jack dictates frequency +//and buffersize to the values it was launched with. +//Supposedly jack_set_buffer_size can set the buffersize +//but that causes some kind of halt and keeps giving me +//zero buffers. +//recordMyDesktop cannot handle buffer size changes. +//FIXME +//There is a callback for buffer size changes that I should use. +//It will provide clean exits, instead of ?segfaults? . +//Continuing though is not possible, with the current layout +//(it might be in some cases, but it will certainly be the cause +//of unpredicted problems). A clean exit is preferable +//and any recording up to that point will be encoded and saved. + jdata->frequency = jack_get_sample_rate(jdata->client); + jdata->buffersize = jack_get_buffer_size(jdata->client); + ring_buffer_size = ( jdata->ringbuffer_secs* + jdata->frequency* + sizeof(jack_default_audio_sample_t)* + jdata->nports); + jdata->sound_buffer = jack_ringbuffer_create((int)(ring_buffer_size+0.5));//round up + jack_set_process_callback(jdata->client, rmdJackCapture, jdata); + jack_on_shutdown(jdata->client, rmdJackShutdown, jdata); + + if (jack_activate(jdata->client)) { + fprintf(stderr, "cannot activate client!\n"); + return 16; + } + + if (rmdSetupPorts(jdata)) { + jack_client_close(jdata->client); + return 17; + } + + return 0; +} + +int rmdStopJackClient(JackData *jdata) { + int ret = 0; + + jack_ringbuffer_free(jdata->sound_buffer); + if (jack_client_close(jdata->client)) { + fprintf(stderr, "Cannot close Jack client!\n"); + ret = 1; + } + +/*TODO*/ +//I need to make some kind of program/thread +//flow diagram to see where it's safe to dlclose +//because here it causes a segfault. + +// if (dlclose(jdata->jack_lib_handle)) { +// fprintf(stderr, "Cannot unload Jack library!\n"); +// ret=1; +// } +// else fprintf(stderr, "Unloaded Jack library.\n"); + + return ret; +} + +#endif diff --git a/src/rmd_jack.h b/src/rmd_jack.h new file mode 100644 index 0000000..a216c1b --- /dev/null +++ b/src/rmd_jack.h @@ -0,0 +1,59 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef RMD_JACK_H +#define RMD_JACK_H 1 + +#include "rmd_types.h" + + +#ifdef HAVE_LIBJACK + +/** +* create and activate client,register ports +* +* \param jdata_t Pointer to JackData struct containing port +* and client information +* +* \returns 0 on Success, error code on failure +* (depending on where the error occured) +*/ +int rmdStartJackClient(JackData *jdata); + +/** +* Close Jack Client +* +* \param jdata_t Pointer to JackData struct containing port +* and client information +* +* \returns 0 on Success, 1 on failure +*/ +int rmdStopJackClient(JackData *jdata); + +#endif + + +#endif diff --git a/src/rmd_load_cache.c b/src/rmd_load_cache.c new file mode 100644 index 0000000..8ca37f6 --- /dev/null +++ b/src/rmd_load_cache.c @@ -0,0 +1,336 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_load_cache.h" + +#include "rmd_cache.h" +#include "rmd_encode_image_buffer.h" +#include "rmd_encode_sound_buffer.h" +#include "rmd_macro.h" +#include "rmd_types.h" + +#include <pthread.h> +#include <signal.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + + +//The number of bytes for every +//sub-block of the y,u and v planes. +//Since the blocks are square +//these are obviously the squares +//of the widths(specified above), +//but the definitions bellow are only +//for convenience anyway. +#define Y_UNIT_BYTES 0x0100 +#define UV_UNIT_BYTES 0x0040 + + +//The frame after retrieval. +//Based on the Header information +//we can read the correct amount of bytes. +typedef struct _CachedFrame{ + FrameHeader *header; + u_int32_t *YBlocks, //identifying number on the grid, + *UBlocks, //starting at top left + *VBlocks; // >> >> + unsigned char *YData, //pointer to data for the blocks that have changed, + *UData, //which have to be remapped + *VData; //on the buffer when reading +}CachedFrame; + + +static void rmdLoadBlock( + unsigned char *dest, + unsigned char *source, + int blockno, + int width, + int height, + int blockwidth) { + + int block_i = blockno / (width / blockwidth),//place on the grid + block_k = blockno % (width / blockwidth); + + for (int j = 0; j < blockwidth; j++)//we copy rows + memcpy( &dest[(block_i * width + block_k) * blockwidth + j * width], + &source[j * blockwidth], + blockwidth); +} + +//returns number of bytes +static int rmdReadZF(void * buffer, size_t size, size_t nmemb, FILE *ucfp, gzFile ifp) { + if ((ifp != NULL && ucfp != NULL) || + (ifp == NULL && ucfp == NULL)) + return -1; + else if (ucfp != NULL) { + return size * fread(buffer, size, nmemb, ucfp); + } else + return gzread(ifp, buffer, size * nmemb); +} + +static int rmdReadFrame(CachedFrame *frame, FILE *ucfp, gzFile ifp) { + int index_entry_size = sizeof(u_int32_t); + + if (frame->header->Ynum > 0) { + if (rmdReadZF( frame->YBlocks, + index_entry_size, + frame->header->Ynum, + ucfp, + ifp) != index_entry_size * frame->header->Ynum) { + return -1; + } + } + + if (frame->header->Unum > 0) { + if (rmdReadZF( frame->UBlocks, + index_entry_size, + frame->header->Unum, + ucfp, + ifp) != index_entry_size * frame->header->Unum) { + return -1; + } + } + + if (frame->header->Vnum > 0) { + if (rmdReadZF( frame->VBlocks, + index_entry_size, + frame->header->Vnum, + ucfp, + ifp) != index_entry_size * frame->header->Vnum) { + return -1; + } + } + + if (frame->header->Ynum > 0) { + if (rmdReadZF( frame->YData, + Y_UNIT_BYTES, + frame->header->Ynum, + ucfp, + ifp) != Y_UNIT_BYTES * frame->header->Ynum) { + return -2; + } + } + + if (frame->header->Unum > 0) { + if (rmdReadZF( frame->UData, + UV_UNIT_BYTES, + frame->header->Unum, + ucfp, + ifp) != UV_UNIT_BYTES * frame->header->Unum) { + return -2; + } + } + + if (frame->header->Vnum > 0) { + if (rmdReadZF( frame->VData, + UV_UNIT_BYTES, + frame->header->Vnum, + ucfp, + ifp) != UV_UNIT_BYTES * frame->header->Vnum) { + return -2; + } + } + + return 0; +} + +void *rmdLoadCache(ProgData *pdata) { + + yuv_buffer *yuv = &pdata->enc_data->yuv; + gzFile ifp = NULL; + FILE *ucfp = NULL; + FILE *afp = pdata->cache_data->afp; + FrameHeader fheader; + CachedFrame frame; + int nth_cache = 1, + audio_end = 0, + extra_frames = 0, //total number of duplicated frames + missing_frames = 0, //if this is found >0 current run will not load + //a frame but it will proccess the previous + thread_exit = 0, //0 success, -1 couldn't find files,1 couldn't remove + blocknum_x = pdata->enc_data->yuv.y_width / Y_UNIT_WIDTH, + blocknum_y = pdata->enc_data->yuv.y_height / Y_UNIT_WIDTH, + blockszy = Y_UNIT_BYTES,//size of y plane block in bytes + blockszuv = UV_UNIT_BYTES;//size of u,v plane blocks in bytes + signed char *sound_data = (signed char *)malloc(pdata->periodsize * pdata->sound_framesize); + + u_int32_t YBlocks[(yuv->y_width * yuv->y_height) / Y_UNIT_BYTES], + UBlocks[(yuv->uv_width * yuv->uv_height) / UV_UNIT_BYTES], + VBlocks[(yuv->uv_width * yuv->uv_height) / UV_UNIT_BYTES]; + + // We allocate the frame that we will use + frame.header = &fheader; + frame.YBlocks = YBlocks; + frame.UBlocks = UBlocks; + frame.VBlocks = VBlocks; + frame.YData = malloc(yuv->y_width * yuv->y_height); + frame.UData = malloc(yuv->uv_width * yuv->uv_height); + frame.VData = malloc(yuv->uv_width * yuv->uv_height); + + //and the we open our files + if (!pdata->args.zerocompression) { + ifp = gzopen(pdata->cache_data->imgdata, "rb"); + if (ifp == NULL) { + thread_exit = -1; + pthread_exit(&thread_exit); + } + } else { + ucfp = fopen(pdata->cache_data->imgdata, "rb"); + if (ucfp == NULL) { + thread_exit = -1; + pthread_exit(&thread_exit); + } + } + + if (!pdata->args.nosound) { + afp = fopen(pdata->cache_data->audiodata, "rb"); + if (afp == NULL) { + thread_exit = -1; + pthread_exit(&thread_exit); + } + } + + //this will be used now to define if we proccess audio or video + //on any given loop. + pdata->avd = 0; + //If sound finishes first,we go on with the video. + //If video ends we will do one more run to flush audio in the ogg file + while (pdata->running) { + //video load and encoding + if (pdata->avd <= 0 || pdata->args.nosound || audio_end) { + if (missing_frames > 0) { + extra_frames++; + missing_frames--; + rmdSyncEncodeImageBuffer(pdata); + } else if (((!pdata->args.zerocompression) && + (gzread(ifp, frame.header, sizeof(FrameHeader)) == + sizeof(FrameHeader) )) || + ((pdata->args.zerocompression) && + (fread(frame.header, sizeof(FrameHeader), 1, ucfp) == 1))) { + //sync + missing_frames += frame.header->current_total - + (extra_frames + frame.header->frameno); + if (pdata->frames_total) { + fprintf(stdout, "\r[%d%%] ", + ((frame.header->frameno + extra_frames) * 100) / pdata->frames_total); + } else + fprintf(stdout, "\r[%d frames rendered] ", + (frame.header->frameno + extra_frames)); + fflush(stdout); + if ( (frame.header->Ynum <= blocknum_x * blocknum_y) && + (frame.header->Unum <= blocknum_x * blocknum_y) && + (frame.header->Vnum <= blocknum_x * blocknum_y) && + !rmdReadFrame( &frame, + (pdata->args.zerocompression ? ucfp : NULL), + (pdata->args.zerocompression ? NULL : ifp)) + ) { + + //load the blocks for each buffer + if (frame.header->Ynum) + for (int j = 0; j < frame.header->Ynum; j++) + rmdLoadBlock( yuv->y, + &frame.YData[j * blockszy], + frame.YBlocks[j], + yuv->y_width, + yuv->y_height, + Y_UNIT_WIDTH); + if (frame.header->Unum) + for (int j = 0; j < frame.header->Unum; j++) + rmdLoadBlock( yuv->u, + &frame.UData[j * blockszuv], + frame.UBlocks[j], + yuv->uv_width, + yuv->uv_height, + UV_UNIT_WIDTH); + if (frame.header->Vnum) + for (int j = 0; j < frame.header->Vnum; j++) + rmdLoadBlock( yuv->v, + &frame.VData[j * blockszuv], + frame.VBlocks[j], + yuv->uv_width, + yuv->uv_height, + UV_UNIT_WIDTH); + + //encode. This is not made in a thread since + //now blocking is not a problem + //and this way sync problems + //can be avoided more easily. + rmdSyncEncodeImageBuffer(pdata); + } else { + raise(SIGINT); + continue; + } + } else { + if (rmdSwapCacheFilesRead( pdata->cache_data->imgdata, + nth_cache, + &ifp, + &ucfp)) { + raise(SIGINT); + } else { + fprintf(stderr, "\t[Cache File %d]", nth_cache); + nth_cache++; + } + continue; + } + //audio load and encoding + } else { + if (!audio_end) { + int nbytes = fread(sound_data, 1, pdata->periodsize* + pdata->sound_framesize, afp); + if (nbytes <= 0) + audio_end = 1; + else + rmdSyncEncodeSoundBuffer(pdata, sound_data); + } + } + } + + pthread_mutex_lock(&pdata->theora_lib_mutex); + pdata->th_encoding_clean = 1; + pthread_cond_signal(&pdata->theora_lib_clean); + pthread_mutex_unlock(&pdata->theora_lib_mutex); + + pthread_mutex_lock(&pdata->vorbis_lib_mutex); + pdata->v_encoding_clean = 1; + pthread_cond_signal(&pdata->vorbis_lib_clean); + pthread_mutex_unlock(&pdata->vorbis_lib_mutex); + fprintf(stdout, "\n"); + + // Clear frame + free(frame.YData); + free(frame.UData); + free(frame.VData); + + free(sound_data); + + if (!pdata->args.nosound) + fclose(afp); + + pthread_exit(&thread_exit); +} diff --git a/src/rmd_load_cache.h b/src/rmd_load_cache.h new file mode 100644 index 0000000..917f31f --- /dev/null +++ b/src/rmd_load_cache.h @@ -0,0 +1,42 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef LOAD_CACHE +#define LOAD_CACHE 1 + +#include "rmd_types.h" + + +/** +* Cache loading and processing thread +* +* \param pdata ProgData struct containing all program data +* +*/ +void *rmdLoadCache(ProgData *pdata); + + +#endif diff --git a/src/rmd_macro.h b/src/rmd_macro.h new file mode 100644 index 0000000..2f1ac88 --- /dev/null +++ b/src/rmd_macro.h @@ -0,0 +1,83 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef RMDMACRO_H +#define RMDMACRO_H 1 + +#include "config.h" + +#include "rmd_types.h" + +#include <limits.h> + + +//define which way we are reading a pixmap +#if __BYTE_ORDER == __LITTLE_ENDIAN +#define __ABYTE 3 +#define __RBYTE 2 +#define __GBYTE 1 +#define __BBYTE 0 + +#elif __BYTE_ORDER == __BIG_ENDIAN + +#define __ABYTE 0 +#define __RBYTE 1 +#define __GBYTE 2 +#define __BBYTE 3 + +#else +#error Only little-endian and big-endian systems are supported +#endif + +#define __RVALUE_32(tmp_val) (((tmp_val)&0x00ff0000)>>16) +#define __GVALUE_32(tmp_val) (((tmp_val)&0x0000ff00)>>8) +#define __BVALUE_32(tmp_val) (((tmp_val)&0x000000ff)) + +#define __R16_MASK 0xf800 +#define __G16_MASK 0x7e0 +#define __B16_MASK 0x1f + +#define __RVALUE_16(tmp_val) ((((tmp_val)&__R16_MASK)>>11)*8) +#define __GVALUE_16(tmp_val) ((((tmp_val)&__G16_MASK)>>5)*4) +#define __BVALUE_16(tmp_val) ((((tmp_val)&__B16_MASK))*8) + +//xfixes pointer data are written as unsigned long +//(even though the server returns CARD32) +//so we need to set the step accordingly to +//avoid problems (amd64 has 8byte ulong) +#define RMD_ULONG_SIZE_T (sizeof(unsigned long)) + +//The width, in bytes, of the blocks +//on which the y,u and v planes are broken. +//These blocks are square. +#define Y_UNIT_WIDTH 0x0010 +#define UV_UNIT_WIDTH 0x0008 + +#define MAX(a, b) ((a) < (b)) ? (b) : (a) +#define MIN(a, b) ((a) > (b)) ? (b) : (a) + +#endif + diff --git a/src/rmd_make_dummy_pointer.c b/src/rmd_make_dummy_pointer.c new file mode 100644 index 0000000..25bb027 --- /dev/null +++ b/src/rmd_make_dummy_pointer.c @@ -0,0 +1,94 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_make_dummy_pointer.h" + +#include "rmd_macro.h" +#include "rmd_types.h" + +#include <X11/Xlib.h> +#include <stdlib.h> + +unsigned char *rmdMakeDummyPointer( Display *display, + DisplaySpecs *specs, + int size, + int color, + int type, + unsigned char *npxl) { + + unsigned long bpixel = XBlackPixel(display, specs->screen); + unsigned long wpixel = XWhitePixel(display, specs->screen); + int i, k, o = '.'; + unsigned long b = color ? 'w' : 'b', w = color ? 'b' : 'w'; + char pmask[1][16][16] = {{ + {w,w,o,o,o,o,o,o,o,o,o,o,o,o,o,o}, + {w,b,w,o,o,o,o,o,o,o,o,o,o,o,o,o}, + {w,b,b,w,o,o,o,o,o,o,o,o,o,o,o,o}, + {w,b,b,b,w,o,o,o,o,o,o,o,o,o,o,o}, + {w,b,b,b,b,w,o,o,o,o,o,o,o,o,o,o}, + {w,b,b,b,b,b,w,o,o,o,o,o,o,o,o,o}, + {w,b,b,b,b,b,b,w,o,o,o,o,o,o,o,o}, + {w,b,b,b,b,b,b,b,w,o,o,o,o,o,o,o}, + {w,b,b,b,b,b,b,b,b,w,o,o,o,o,o,o}, + {w,b,b,b,b,b,w,w,w,w,o,o,o,o,o,o}, + {w,b,b,b,b,b,w,o,o,o,o,o,o,o,o,o}, + {w,b,b,w,w,b,b,w,o,o,o,o,o,o,o,o}, + {w,b,w,o,w,b,b,w,o,o,o,o,o,o,o,o}, + {w,w,o,o,o,w,b,b,w,o,o,o,o,o,o,o}, + {o,o,o,o,o,w,b,b,w,o,o,o,o,o,o,o}, + {o,o,o,o,o,o,w,w,o,o,o,o,o,o,o,o}} + }; + unsigned char *ret = malloc(size * sizeof(char[size * 4])); + unsigned char wp[4] = { + (wpixel ^ 0xff000000) >> 24, + (wpixel ^ 0x00ff0000) >> 16, + (wpixel ^ 0x0000ff00) >> 8, + (wpixel ^ 0x000000ff) + }; + unsigned char bp[4] = { + (bpixel ^ 0xff000000) >> 24, + (bpixel ^ 0x00ff0000) >> 16, + (bpixel ^ 0x0000ff00) >> 8, + (bpixel ^ 0x000000ff) + }; + + *npxl = ((wp[0] - 1) != bp[0]) ? wp[0] - 100 : wp[0] - 102; + for (i = 0; i < size; i++) { + for (k = 0; k < size; k++) { + ret[(i * size + k) * 4 + __ABYTE] = (pmask[type][i][k] == 'w') ? + wp[0]:(pmask[type][i][k] == 'b') ? bp[0] : *npxl; + ret[(i * size + k) * 4 + __RBYTE] = (pmask[type][i][k] == 'w') ? + wp[1]:(pmask[type][i][k] == 'b') ? bp[1] : *npxl; + ret[(i * size + k) * 4 + __GBYTE] = (pmask[type][i][k] == 'w') ? + wp[2]:(pmask[type][i][k] == 'b') ? bp[2] : *npxl; + ret[(i * size + k) * 4 + __BBYTE] = (pmask[type][i][k] == 'w') ? + wp[3]:(pmask[type][i][k] == 'b') ? bp[3] : *npxl; + } + } + + return ret; +} diff --git a/src/rmd_make_dummy_pointer.h b/src/rmd_make_dummy_pointer.h new file mode 100644 index 0000000..3eccd42 --- /dev/null +++ b/src/rmd_make_dummy_pointer.h @@ -0,0 +1,59 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef MAKE_DUMMY_POINTER_H +#define MAKE_DUMMY_POINTER_H 1 + +#include "rmd_types.h" + + +/** +* Create an array containing the data for the dummy pointer +* +* \param specs DisplaySpecs struct with +* information about the display to be recorded +* +* \param size Pointer size, always square, always 16.(exists only +* for the possibility to create more dummy cursors) +* \param color 0 white, 1 black +* +* \param type Always 0.(exists only for the possibility to create +* more dummy cursors) +* +* \param npxl Return of pixel value that denotes non-drawing, while +* applying the cursor on the target image +* +* \returns Pointer to pixel data of the cursor +*/ +unsigned char *rmdMakeDummyPointer(Display *display, + DisplaySpecs *specs, + int size, + int color, + int type, + unsigned char *npxl); + + +#endif diff --git a/src/rmd_math.c b/src/rmd_math.c new file mode 100644 index 0000000..1cf3d29 --- /dev/null +++ b/src/rmd_math.c @@ -0,0 +1,33 @@ +/****************************************************************************** +* recordMyDesktop - rmd_math.c * +******************************************************************************* +* * +* Copyright (C) 2008 John Varouhakis * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_math.h" + +#include <math.h> + +double rmdRoundf(double val) { + return val < 0.0 ? ceilf(val - .5) : floorf(val + 0.5); +} diff --git a/src/rmd_math.h b/src/rmd_math.h new file mode 100644 index 0000000..87c6166 --- /dev/null +++ b/src/rmd_math.h @@ -0,0 +1,44 @@ +/****************************************************************************** +* recordMyDesktop - rmd_math.h * +******************************************************************************* +* * +* Copyright (C) 2008 John Varouhakis * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef RMD_MATH_H +#define RMD_MATH_H 1 + +/* + * Since roundf depends on C99, using it might make + * the code non-portable. rmdRoundf solves this + * problem, by behaving identically with roundf + * and being portable (floorf and ceilf, that are + * used in the implementation, are defined in C89) + * + * \param val Number to be rounded + * + * \returns val rounded + * + */ +double rmdRoundf( double val ); + +#endif + diff --git a/src/rmd_opendev.c b/src/rmd_opendev.c new file mode 100644 index 0000000..37fb33c --- /dev/null +++ b/src/rmd_opendev.c @@ -0,0 +1,189 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_opendev.h" + +#ifdef HAVE_LIBASOUND + #include <alsa/asoundlib.h> +#else + #include <sys/ioctl.h> + #include <sys/soundcard.h> +#endif + +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#include <fcntl.h> + + +#ifdef HAVE_LIBASOUND + +snd_pcm_t *rmdOpenDev( const char *pcm_dev, + unsigned int *channels, + unsigned int *frequency, + snd_pcm_uframes_t *buffsize, + snd_pcm_uframes_t *periodsize, + unsigned int *periodtime, + int *hard_pause) { + + snd_pcm_t *mhandle; + snd_pcm_hw_params_t *hwparams; + unsigned int periods = 2; + unsigned int exactrate = *frequency; + + // The compiler might warn us because the expansion starts with + // assert(&hwparams) + snd_pcm_hw_params_alloca(&hwparams); + + if (snd_pcm_open(&mhandle, pcm_dev, SND_PCM_STREAM_CAPTURE, SND_PCM_ASYNC) < 0) { + fprintf(stderr, "Couldn't open PCM device %s\n", pcm_dev); + return NULL; + } else + fprintf(stderr, "Opened PCM device %s\n", pcm_dev); + + if (snd_pcm_hw_params_any(mhandle, hwparams) < 0) { + fprintf(stderr, "Couldn't configure PCM device.\n"); + return NULL; + } + + if (snd_pcm_hw_params_set_access(mhandle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) { + fprintf(stderr, "Couldn't set access.\n"); + return NULL; + } + + if (snd_pcm_hw_params_set_format(mhandle, hwparams, SND_PCM_FORMAT_S16_LE) < 0) { + fprintf(stderr, "Couldn't set format.\n"); + return NULL; + } + + if (snd_pcm_hw_params_set_rate_near(mhandle, hwparams, &exactrate, 0) < 0) { + fprintf(stderr, "Couldn't set frequency.\n"); + return NULL; + } + + if (*frequency != exactrate) { + fprintf(stderr, "Playback frequency %dHz is not available...\n" + "Using %dHz instead.\n", + *frequency, exactrate); + + *frequency = exactrate; + } + + if (snd_pcm_hw_params_set_channels_near(mhandle, hwparams, channels) < 0) { + fprintf(stderr, "Couldn't set channels number.\n"); + return NULL; + } + + if (*channels>2) { + fprintf(stderr, "Channels number should be 1(mono) or 2(stereo).\n"); + return NULL; + } + + if (snd_pcm_hw_params_set_periods_near(mhandle, hwparams, &periods, 0) < 0) { + fprintf(stderr, "Couldn't set periods.\n"); + return NULL; + } + + if (snd_pcm_hw_params_set_buffer_size_near(mhandle, hwparams, buffsize) < 0) { + fprintf(stderr, "Couldn't set buffer size.\n"); + return NULL; + } + + if (snd_pcm_hw_params(mhandle, hwparams) < 0) { + fprintf(stderr, "Couldn't set hardware parameters.\n"); + return NULL; + } + + if (hard_pause != NULL) { + if (!snd_pcm_hw_params_can_pause(hwparams)) + *hard_pause = 1; + } + + if (periodsize != NULL) + snd_pcm_hw_params_get_period_size(hwparams, periodsize, 0); + + if (periodtime != NULL) + snd_pcm_hw_params_get_period_time(hwparams, periodtime, 0); + + fprintf(stderr, + "Recording on device %s is set to:\n%d channels at %dHz\n", + pcm_dev, *channels, *frequency); + + snd_pcm_prepare(mhandle); + + return mhandle; +} + +#else + +int rmdOpenDev(const char *pcm_dev, unsigned int channels, unsigned int frequency) { + int fd ; + unsigned int value; + + fd = open(pcm_dev, O_RDONLY); + if (fd < 0) + return -1; + + if (ioctl(fd, SNDCTL_DSP_GETFMTS, &value) < 0) { + fprintf(stderr, "Couldn't get audio format list\n"); + return -1; + } + + if (value & AFMT_S16_LE) { + value = AFMT_S16_LE; + } else if (value & AFMT_S16_BE) { + value = AFMT_S16_BE; + } else { + fprintf(stderr, "Soundcard doesn't support signed 16-bit-data\n"); + return -1; + } + + if (ioctl(fd, SNDCTL_DSP_SETFMT, &value) < 0) { + fprintf(stderr, "Couldn't set audio format\n" ); + return -1; + } + + value = channels; + if (ioctl(fd, SNDCTL_DSP_CHANNELS, &value) < 0) { + fprintf(stderr, "Cannot set the number of channels\n" ); + return -1; + } + + value = frequency; + if (ioctl(fd, SNDCTL_DSP_SPEED, &value) < 0) { + fprintf(stderr, "Couldn't set audio frequency\n" ); + return -1; + } + + if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) & ~O_NONBLOCK) < 0) { + fprintf(stderr, "Couldn't set audio blocking mode\n" ); + return -1; + } + + return fd; +} +#endif diff --git a/src/rmd_opendev.h b/src/rmd_opendev.h new file mode 100644 index 0000000..06dfc64 --- /dev/null +++ b/src/rmd_opendev.h @@ -0,0 +1,84 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef OPENDEV_H +#define OPENDEV_H 1 + +#include "rmd_types.h" + + +#ifdef HAVE_LIBASOUND +/** +* Try to open (alsa) sound device, with the desired parameters, +* and place the obtained ones on their place +* +* \param pcm_dev name of the device +* +* \param channels desired number of channels +* (gets modified with the acieved value) +* +* \param frequency desired frequency(gets modified with the acieved value) +* +* \param buffsize Size of buffer +* +* \param periodsize Size of a period(can be NULL) +* +* \param periodtime Duration of a period(can be NULL) +* +* \param hardpause Set to 1 when the device has to be stopped during pause +* and to 0 when it supports pausing +* (can be NULL) +* +* \returns snd_pcm_t handle on success, NULL on failure +*/ +snd_pcm_t *rmdOpenDev(const char *pcm_dev, + unsigned int *channels, + unsigned int *frequency, + snd_pcm_uframes_t *buffsize, + snd_pcm_uframes_t *periodsize, + unsigned int *periodtime, + int *hardpause); +#else +/** +* Try to open (OSS) sound device, with the desired parameters. +* +* +* \param pcm_dev name of the device +* +* \param channels desired number of channels +* +* \param frequency desired frequency +* +* +* \returns file descriptor of open device,-1 on failure +*/ +int rmdOpenDev(const char *pcm_dev, + unsigned int channels, + unsigned int frequency); +#endif + + +#endif diff --git a/src/rmd_parseargs.c b/src/rmd_parseargs.c new file mode 100644 index 0000000..12d2cd4 --- /dev/null +++ b/src/rmd_parseargs.c @@ -0,0 +1,511 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* Copyright (C) 2009 Martin Nordholts * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_parseargs.h" + +#include "rmd_types.h" + +#include <popt.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + + +#ifdef HAVE_LIBJACK +#define RMD_LIBJACK_STATUS "Enabled" +#define RMD_USE_JACK_EXTRA_FLAG 0 +#else +#define RMD_LIBJACK_STATUS "Disabled" +#define RMD_USE_JACK_EXTRA_FLAG POPT_ARGFLAG_DOC_HIDDEN +#endif + +#ifdef HAVE_LIBASOUND +#define RMD_LIBASOUND_STATUS "ALSA" +#else +#define RMD_LIBASOUND_STATUS "OSS" +#endif + +#define RMD_ARG_DELAY 1 +#define RMD_ARG_DUMMY_CURSOR 2 +#define RMD_ARG_USE_JACK 3 + +#define RMD_OPTION_TABLE(name, table) \ + { NULL, '\0', \ + POPT_ARG_INCLUDE_TABLE, (table), \ + 0, (name), NULL } + + +static void rmdPrintAndExit(poptContext con, enum poptCallbackReason reason, const struct poptOption *opt, const char *arg, const void *data); +static boolean rmdValidateArguments(const ProgArgs *args); + + +boolean rmdParseArgs(int argc, char **argv, ProgArgs *arg_return) { + poptContext popt_context = NULL; + boolean no_cursor = FALSE; + boolean quick_subsampling = FALSE; + boolean compress_cache = FALSE; + boolean success = TRUE; + int arg_id = 0; + + // Setup the option tables + struct poptOption generic_options[] = { + { NULL, '\0', + POPT_ARG_CALLBACK, (void *)rmdPrintAndExit, 0, + NULL, NULL }, + + { "help", 'h', + POPT_ARG_NONE, NULL, 0, + "Print this help and exit.", + NULL }, + + { "version", '\0', + POPT_ARG_NONE, NULL, 0, + "Print program version and exit.", + NULL }, + + { "print-config", '\0', + POPT_ARG_NONE, NULL, 0, + "Print info about options selected during compilation and exit.", + NULL }, + + POPT_TABLEEND }; + + struct poptOption image_options[] = { + { "windowid", '\0', + POPT_ARG_INT, &arg_return->windowid, 0, + "id of window to be recorded.", + "id_of_window" }, + + { "display", '\0', + POPT_ARG_STRING, &arg_return->display, 0, + "Display to connect to.", + "DISPLAY" }, + + { "x", 'x', + POPT_ARG_INT, &arg_return->x, 0, + "Offset in x direction.", + "N>=0" }, + + { "y", 'y', + POPT_ARG_INT, &arg_return->y, 0, + "Offset in y direction.", + "N>=0" }, + + { "width", '\0', + POPT_ARG_INT, &arg_return->width, 0, + "Width of recorded window.", + "N>0" }, + + { "height", '\0', + POPT_ARG_INT, &arg_return->height, 0, + "Height of recorded window.", + "N>0" }, + + { "dummy-cursor", '\0', + POPT_ARG_STRING, NULL, RMD_ARG_DUMMY_CURSOR, + "Color of the dummy cursor [black|white]", + "color" }, + + { "no-cursor", '\0', + POPT_ARG_NONE, &no_cursor, 0, + "Disable drawing of the cursor.", + NULL }, + + { "no-shared", '\0', + POPT_ARG_NONE, &arg_return->noshared, 0, + "Disable usage of MIT-shared memory extension(Not Recommended!).", + NULL }, + + { "full-shots", '\0', + POPT_ARG_NONE, &arg_return->full_shots, 0, + "Take full screenshot at every frame(Not recomended!).", + NULL }, + + { "follow-mouse", '\0', + POPT_ARG_NONE, &arg_return->follow_mouse, 0, + "Makes the capture area follow the mouse cursor. Autoenables --full-shots.", + NULL }, + + { "quick-subsampling", '\0', + POPT_ARG_NONE, &quick_subsampling, 0, + "Do subsampling of the chroma planes by discarding, not averaging.", + NULL }, + + { "fps", '\0', + POPT_ARG_FLOAT, &arg_return->fps, 0, + "A positive number denoting desired framerate.", + "N(number>0.0)" }, + + POPT_TABLEEND }; + + struct poptOption sound_options[] = { + { "channels", '\0', + POPT_ARG_INT, &arg_return->channels, 0, + "A positive number denoting desired sound channels in recording.", + "N" }, + + { "freq", '\0', + POPT_ARG_INT, &arg_return->frequency, 0, + "A positive number denoting desired sound frequency.", + "N" }, + + { "buffer-size", '\0', + POPT_ARG_INT, &arg_return->buffsize, 0, + "A positive number denoting the desired sound buffer size (in frames, when using ALSA or OSS)", + "N" }, + + { "ring-buffer-size", '\0', + POPT_ARG_FLOAT, &arg_return->jack_ringbuffer_secs, 0, + "A float number denoting the desired ring buffer size (in seconds, when using JACK only).", + "N" }, + + { "device", '\0', + POPT_ARG_STRING, &arg_return->device, 0, + "Sound device(default " DEFAULT_AUDIO_DEVICE ").", + "SOUND_DEVICE" }, + + { "use-jack", '\0', + POPT_ARG_STRING | RMD_USE_JACK_EXTRA_FLAG, &arg_return->x, RMD_ARG_USE_JACK, + "Record audio from the specified list of space-separated jack ports.", + "port1 port2... portn" }, + + { "no-sound", '\0', + POPT_ARG_NONE, &arg_return->nosound, 0, + "Do not record sound.", + NULL }, + + POPT_TABLEEND }; + + struct poptOption encoding_options[] = { + { "on-the-fly-encoding", '\0', + POPT_ARG_NONE, &arg_return->encOnTheFly, 0, + "Encode the audio-video data, while recording.", + NULL }, + + { "v_quality", '\0', + POPT_ARG_INT, &arg_return->v_quality, 0, + "A number from 0 to 63 for desired encoded video quality(default 63).", + "n" }, + + { "v_bitrate", '\0', + POPT_ARG_INT, &arg_return->v_bitrate, 0, + "A number from 0 to 2000000 for desired encoded video bitrate(default 0).", + "n" }, + + { "s_quality", '\0', + POPT_ARG_INT, &arg_return->s_quality, 0, + "Desired audio quality(-1 to 10).", + "n" }, + + POPT_TABLEEND }; + + struct poptOption misc_options[] = { + { "rescue", '\0', + POPT_ARG_STRING, &arg_return->rescue_path, 0, + "Encode data from a previous, crashed, session.", + "path_to_data" }, + + { "no-encode", '\0', + POPT_ARG_NONE | POPT_ARGFLAG_DOC_HIDDEN, &arg_return->no_encode, 0, + "Do not encode any data after recording is complete. This is instead done manually afterwards with --rescue.", + NULL }, + + { "no-wm-check", '\0', + POPT_ARG_NONE, &arg_return->nowmcheck, 0, + "Do not try to detect the window manager(and set options according to it)", + NULL }, + + { "no-frame", '\0', + POPT_ARG_NONE, &arg_return->noframe, 0, + "Don not show the frame that visualizes the recorded area.", + NULL }, + + { "pause-shortcut", '\0', + POPT_ARG_STRING, &arg_return->pause_shortcut, 0, + "Shortcut that will be used for (un)pausing (default Control+Mod1+p).", + "MOD+KEY" }, + + { "stop-shortcut", '\0', + POPT_ARG_STRING, &arg_return->stop_shortcut, 0, + "Shortcut that will be used to stop the recording (default Control+Mod1+s).", + "MOD+KEY" }, + + { "compress-cache", '\0', + POPT_ARG_NONE, &compress_cache, 0, + "Image data are cached with light compression.", + NULL }, + + { "workdir", '\0', + POPT_ARG_STRING, &arg_return->workdir, 0, + "Location where a temporary directory will be created to hold project files(default $HOME).", + "DIR" }, + + { "delay", '\0', + POPT_ARG_STRING, &arg_return->delay, RMD_ARG_DELAY, + "Number of secs(default), minutes or hours before capture starts(number can be float)", + "n[H|h|M|m]" }, + + { "overwrite", '\0', + POPT_ARG_NONE, &arg_return->overwrite, 0, + "If there is already a file with the same name, delete it (default is to add a number postfix to the new one).", + NULL }, + + { "output", 'o', + POPT_ARG_STRING, &arg_return->filename, 0, + "Name of recorded video(default out.ogv).", + "filename" }, + + POPT_TABLEEND }; + + struct poptOption rmd_args[] = { + RMD_OPTION_TABLE("Generic Options", generic_options), + RMD_OPTION_TABLE("Image Options", image_options), + RMD_OPTION_TABLE("Sound Options", sound_options), + RMD_OPTION_TABLE("Encoding Options", encoding_options), + RMD_OPTION_TABLE("Misc Options", misc_options), + POPT_TABLEEND }; + + + // Some trivial setup + popt_context = poptGetContext(NULL, argc, (const char **)argv, rmd_args, 0); + poptSetOtherOptionHelp(popt_context, "[OPTIONS]^filename"); + + + // Parse the arguments + while ((arg_id = poptGetNextOpt(popt_context)) > 0) { + char *arg = poptGetOptArg(popt_context); + + // Most arguments are handled completely by libpopt but we + // handle some by ourself, namely those in this switch case + switch (arg_id) { + case RMD_ARG_DELAY: + { + float num = atof(arg); + + if (num > 0.0) { + int k; + for (k = 0; k < strlen(arg); k++) { + if ((arg[k] == 'M') || (arg[k] == 'm')) { + num *= 60.0; + break; + } + else if ((arg[k] == 'H') || (arg[k] == 'h')) { + num *= 3600.0; + break; + } + } + arg_return->delay = (int) num; + } else { + fprintf(stderr, + "Argument Usage: --delay n[H|h|M|m]\n" + "where n is a float number\n"); + success = FALSE; + } + } + break; + + case RMD_ARG_DUMMY_CURSOR: + { + if (!strcmp(arg, "white")) + arg_return->cursor_color = 0; + else if (!strcmp(arg, "black")) + arg_return->cursor_color = 1; + else { + fprintf(stderr, + "Argument Usage:\n" + " --dummy-cursor [black|white]\n"); + success = FALSE; + } + arg_return->have_dummy_cursor = TRUE; + arg_return->xfixes_cursor = FALSE; + } + break; + + case RMD_ARG_USE_JACK: + { + arg_return->jack_nports = 0; + + while (arg) { + + arg_return->jack_nports++; + + arg_return->jack_port_names[arg_return->jack_nports - 1] = malloc(strlen(arg) + 1); + strcpy(arg_return->jack_port_names[arg_return->jack_nports - 1], arg); + + arg = poptGetOptArg(popt_context); + } + + if (arg_return->jack_nports > 0) { + arg_return->use_jack = 1; + } else { + fprintf(stderr, + "Argument Usage: --use-jack port1 port2... portn\n"); + success = FALSE; + } + + if (RMD_USE_JACK_EXTRA_FLAG == POPT_ARGFLAG_DOC_HIDDEN) { + fprintf(stderr, + "Warning, will ignore --use-jack flags, no libjack support in build.\n"); + } + } + + default: + break; + } + } + + if (arg_id == -1) { + // Parsing is complete, perform final adjustments + if (no_cursor) + arg_return->xfixes_cursor = FALSE; + + if (quick_subsampling) + arg_return->no_quick_subsample = FALSE; + + if (compress_cache) + arg_return->zerocompression = FALSE; + + if (arg_return->follow_mouse) + arg_return->full_shots = TRUE; + + if (!arg_return->filename) + arg_return->filename = strdup(poptGetArg(popt_context)); + } else { + // Parsing error, say what went wrong + const char *str = poptBadOption(popt_context, 0); + + success = FALSE; + + fprintf(stderr, + "Error when parsing `%s': ", str); + + switch (arg_id) { + case POPT_ERROR_NOARG: + fprintf(stderr, "Missing argument\n"); + break; + + case POPT_ERROR_BADNUMBER: + fprintf(stderr, "Bad number\n"); + break; + + default: + fprintf(stderr, "libpopt error: %d\n", arg_id); + break; + } + } + + // Make sure argument ranges are valid + success = success && rmdValidateArguments(arg_return); + + // Clean up + poptFreeContext(popt_context); + + return success; +} + +static boolean rmdValidateArguments(const ProgArgs *args) +{ + boolean success = TRUE; + + if (args->x < 0) { + fprintf(stdout, "-x must not be less than 0.\n"); + success = FALSE; + } + if (args->y < 0) { + fprintf(stdout, "-y must not be less than 0.\n"); + success = FALSE; + } + if (args->width < 0) { + fprintf(stdout, "--width must be larger than 0.\n"); + success = FALSE; + } + if (args->height < 0) { + fprintf(stdout, "--height must be larger than 0.\n"); + success = FALSE; + } + if (args->fps <= 0) { + fprintf(stdout, "--fps must be larger than 0.\n"); + success = FALSE; + } + if (args->v_quality < 0 || args->v_quality > 63) { + fprintf(stdout, "--v_quality must be within the inclusive range [0-63].\n"); + success = FALSE; + } + if (args->v_bitrate < 0 || args->v_quality > 2000000) { + fprintf(stdout, "--v_bitrate must be within the inclusive range [0-2000000].\n"); + success = FALSE; + } + if (args->frequency <= 0) { + fprintf(stdout, "--frequency must be larger than 0.\n"); + success = FALSE; + } + if (args->channels <= 0) { + fprintf(stdout, "--channels must be larger than 0.\n"); + success = FALSE; + } + if (args->buffsize <= 0) { + fprintf(stdout, "--buffer-size must be larger than 0.\n"); + success = FALSE; + } + if (args->jack_ringbuffer_secs <= 0) { + fprintf(stdout, "--jack-buffer-size must be larger than 0.\n"); + success = FALSE; + } + + return success; +} + +static void rmdPrintAndExit( poptContext con, + enum poptCallbackReason reason, + const struct poptOption *opt, + const char *arg, + const void *data) +{ + if (strcmp(opt->longName, "version") == 0) { + fprintf(stderr, "recordMyDesktop v%s\n\n", VERSION); + } else if (strcmp(opt->longName, "help") == 0) { + poptPrintHelp(con, stdout, 0); + fprintf(stdout, + "\n" + "\tIf no other options are specified, filename can be given without the -o switch.\n" + "\n" + "\n"); + } else if (strcmp(opt->longName, "print-config") == 0) { + fprintf(stdout, + "\n" + "recordMyDesktop was compiled with the following options:\n" + "\n" + "Jack:\t\t\t" RMD_LIBJACK_STATUS "\n" + "Default Audio Backend:\t" RMD_LIBASOUND_STATUS "\n" + "\n" + "\n"); + } + + exit(0); +} diff --git a/src/rmd_parseargs.h b/src/rmd_parseargs.h new file mode 100644 index 0000000..42f2bac --- /dev/null +++ b/src/rmd_parseargs.h @@ -0,0 +1,47 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef PARSEARGS_H +#define PARSEARGS_H 1 + +#include "rmd_types.h" + + +/** +* Fill ProgArgs struct with arguments entered at execution +* +* \param argc argc as entered from main +* +* \param argv argv as entered from main +* +* \param arg_return ProgArgs struct to be filled with the options +* +* \returns 0 on Success 1 on Failure +*/ +boolean rmdParseArgs(int argc, char **argv, ProgArgs *arg_return); + + +#endif diff --git a/src/rmd_poll_events.c b/src/rmd_poll_events.c new file mode 100644 index 0000000..49f2478 --- /dev/null +++ b/src/rmd_poll_events.c @@ -0,0 +1,245 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_poll_events.h" + +#include "rmd_frame.h" +#include "rmd_macro.h" +#include "rmd_rectinsert.h" +#include "rmd_types.h" + +#include <X11/Xlib.h> +#include <X11/Xlibint.h> +#include <X11/extensions/Xdamage.h> + +#include <stdio.h> +#include <stdlib.h> +#include <signal.h> +#include <pthread.h> + + +static int clip_event_area(XDamageNotifyEvent *e, XRectangle *cliprect, XRectangle *res) +{ + +#if 0 + printf("got area %x,%x %x,%x\n", + e->area.x, + e->area.y, + e->area.width, + e->area.height); +#endif + + if ( e->area.x <= cliprect->x && + e->area.y <= cliprect->y && + e->area.width >= cliprect->width && + e->area.height >= cliprect->height) { + + /* area completely covers cliprect, cliprect becomes the area */ + res->x = cliprect->x; + res->y = cliprect->y; + res->width = cliprect->width; + res->height = cliprect->height; + + } else if ( e->area.x + e->area.width < cliprect->x || + e->area.x + e->area.width > cliprect->x + cliprect->width || + e->area.y + e->area.height < cliprect->y || + e->area.y + e->area.height > cliprect->y + cliprect->height) { + + /* area has at least one axis with zero overlap, so they can't overlap */ + return 0; + + } else { + + /* areas partially overlap */ + res->x = MAX(e->area.x, cliprect->x); + res->width = MIN(e->area.x + e->area.width, cliprect->x + cliprect->width) - res->x; + + res->y = MAX(e->area.y, cliprect->y); + res->height = MIN(e->area.y + e->area.height, cliprect->y + cliprect->height) - res->y; + + if (!res->width || !res->height) + return 0; + } + +#if 0 + printf("clipped to %x,%x %x,%x\n", + res->x, + res->y, + res->width, + res->height); +#endif + + return 1; +} + + +/* Try align xrect to even boundaries relative to cliprect, + * this is done for the UV routines which operate at 2x2 rgb pixel granularity. + */ +static void uv_align(XRectangle *cliprect, XRectangle *xrect) { + XRectangle rel; + + rel.x = xrect->x - cliprect->x; + rel.y = xrect->y - cliprect->y; + + if (rel.x % 2) { + rel.x -= 1; + rel.width = xrect->width + 1; + } else { + rel.width = xrect->width; + } + + if (rel.y % 2) { + rel.y -= 1; + rel.height = xrect->height + 1; + } else { + rel.height = xrect->height; + } + + /* XXX: note when cliprect prevents an even width, we can't do anything + * about it. rmd could force even-sized recording windows to prevent + * this, but that would be kind of annoying. For now it's assumed + * the UV routines will handle the exception - which might temporarily + * mean they just lop the odd row/column off the edge. + */ + if (rel.width % 2 && rel.width + rel.x < cliprect->x + cliprect->width) + rel.width++; + + if (rel.height % 2 && rel.height + rel.y < cliprect->y + cliprect->height) + rel.height++; +} + + +void rmdInitEventsPolling(ProgData *pdata) { + Window root_return, + parent_return, + *children; + unsigned int i, + nchildren; + + XSelectInput (pdata->dpy, pdata->specs.root, SubstructureNotifyMask); + + if (!pdata->args.full_shots) { + XQueryTree ( pdata->dpy, + pdata->specs.root, + &root_return, + &parent_return, + &children, + &nchildren); + + for (i = 0; i < nchildren; i++) { + XWindowAttributes attribs; + if (XGetWindowAttributes (pdata->dpy, children[i], &attribs)) { + if (!attribs.override_redirect && attribs.depth == pdata->specs.depth) + XDamageCreate( pdata->dpy, + children[i], + XDamageReportRawRectangles); + } + } + XFree(children); + XDamageCreate( pdata->dpy, + pdata->specs.root, + XDamageReportRawRectangles); + } +} + + +void rmdEventLoop(ProgData *pdata) { + int inserts = 0; + + XEvent event; + + while (XPending(pdata->dpy)) { + XNextEvent(pdata->dpy, &event); + if (event.type == KeyPress) { + XKeyEvent *e = (XKeyEvent *)(&event); + if (e->keycode == pdata->pause_key.key) { + int i = 0; + int found = 0; + for (i = 0; i < pdata->pause_key.modnum; i++) { + if (pdata->pause_key.mask[i] == e->state) { + found = 1; + break; + } + } + if (found) { + raise(SIGUSR1); + continue; + } + } + if (e->keycode == pdata->stop_key.key) { + int i = 0; + int found = 0; + for (i = 0; i < pdata->stop_key.modnum; i++) { + if (pdata->stop_key.mask[i] == e->state) { + found = 1; + break; + } + } + if (found) { + raise(SIGINT); + continue; + } + } + } else if (event.type == Expose) { + + if (event.xexpose.count != 0) + continue; + else if (!pdata->args.noframe) { + rmdDrawFrame( pdata->dpy, + pdata->specs.screen, + pdata->shaped_w, + pdata->brwin.rrect.width, + pdata->brwin.rrect.height); + } + + } else if (!pdata->args.full_shots) { + if (event.type == MapNotify ) { + XWindowAttributes attribs; + + if (!((XMapEvent *)(&event))->override_redirect&& + XGetWindowAttributes( pdata->dpy, + event.xcreatewindow.window, + &attribs)) { + + if (!attribs.override_redirect && attribs.depth == pdata->specs.depth) + XDamageCreate( pdata->dpy, + event.xcreatewindow.window, + XDamageReportRawRectangles); + } + } else if (event.type == pdata->damage_event + XDamageNotify ) { + XDamageNotifyEvent *e = (XDamageNotifyEvent *)&event; + XRectangle xrect; + + if (clip_event_area(e, &pdata->brwin.rrect, &xrect)) { + uv_align(&pdata->brwin.rrect, &xrect); + inserts += rmdRectInsert(&pdata->rect_root, &xrect); + } + } + } + } +} diff --git a/src/rmd_poll_events.h b/src/rmd_poll_events.h new file mode 100644 index 0000000..a1902cb --- /dev/null +++ b/src/rmd_poll_events.h @@ -0,0 +1,49 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef POLL_EVENTS_H +#define POLL_EVENTS_H 1 + +#include "rmd_types.h" + + +/** +* Start listening to damage and substructure notify events +* (needed before rmdEventLoop call) +* \param pdata ProgData struct containing all program data +*/ +void rmdInitEventsPolling(ProgData *pdata); + +/** +* Loop calling XNextEvent.Retrieve and place on +* list damage events that arive, create damage for new windows +* and pickup key events for shortcuts. +* \param pdata ProgData struct containing all program data +*/ +void rmdEventLoop(ProgData *pdata); + + +#endif diff --git a/src/rmd_queryextensions.c b/src/rmd_queryextensions.c new file mode 100644 index 0000000..4484866 --- /dev/null +++ b/src/rmd_queryextensions.c @@ -0,0 +1,88 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_queryextensions.h" + +#include "rmd_types.h" + +#include <X11/extensions/shape.h> +#include <X11/extensions/Xfixes.h> +#include <X11/extensions/Xdamage.h> +#include <stdlib.h> + + + +void rmdQueryExtensions( Display *dpy, + ProgArgs *args, + int *damage_event, + int *damage_error, + int *shm_opcode) { + int xf_event_basep, + xf_error_basep, + shm_event_base, + shm_error_base, + shape_event_base, + shape_error_base; + + if ( !args->full_shots && + !XDamageQueryExtension(dpy, damage_event, damage_error)) { + + fprintf(stderr, "XDamage extension not found!!!\n" + "Try again using the --full-shots option, though\n" + "enabling XDamage is highly recommended,\n" + "for performance reasons.\n"); + exit(4); + } + + if ( !args->noshared && + !XQueryExtension(dpy, "MIT-SHM", shm_opcode, &shm_event_base, &shm_error_base)) { + + args->noshared = 1; + fprintf(stderr, "Shared Memory extension not present!\n" + "Try again using the --no-shared option\n"); + exit(5); + } + + if ( args->xfixes_cursor && + XFixesQueryExtension(dpy, &xf_event_basep, &xf_error_basep) == False) { + + args->xfixes_cursor = 0; + fprintf(stderr, "Xfixes extension not present!\n" + "Please run with the -dummy-cursor or" + " --no-cursor option.\n"); + exit(6); + } + + if ( !args->noframe && + !XShapeQueryExtension(dpy, &shape_event_base, &shape_error_base)) { + + fprintf(stderr, "XShape Not Found!!!\n" + "Frame won't be available.\n"); + + args->noframe = 1; + } +} diff --git a/src/rmd_queryextensions.h b/src/rmd_queryextensions.h new file mode 100644 index 0000000..432fa6c --- /dev/null +++ b/src/rmd_queryextensions.h @@ -0,0 +1,53 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef QUERYEXTENSIONS_H +#define QUERYEXTENSIONS_H 1 + +#include "rmd_types.h" + + +/** +* Check if needed extensions are present +* +* \param dpy Connection to the server +* +* \param args ProgArgs struct containing the user-set options +* +* \param damage_event gets filled with damage event number +* +* \param damage_error gets filled with damage error number +* +* \note Can be an exit point if extensions are not found +*/ +void rmdQueryExtensions(Display *dpy, + ProgArgs *args, + int *damage_event, + int *damage_error, + int *shm_opcode); + + +#endif diff --git a/src/rmd_rectinsert.c b/src/rmd_rectinsert.c new file mode 100644 index 0000000..2d2fd8c --- /dev/null +++ b/src/rmd_rectinsert.c @@ -0,0 +1,480 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_rectinsert.h" + +#include "rmd_types.h" + +#include <stdlib.h> + + +/** +* Collide two rectangles and dictate most sane action for insertion, +* as well as provide the updated rectangle(s) +* \param xrect1 resident rectangle +* +* \param xrect2 New rectangle +* +* \param xrect_return Pointer to rectangles to be inserted +* +* \param nrects number of entries in xrect_return +* +* \retval 0 No collision +* +* \retval 1 xrect1 is covered by xrect2 +* +* \retval 2 xrect2 is covered by xrect1 +* +* \retval -1 xrect1 was broken (new is picked up in xrect_return) +* +* \retval -2 xrect2 was broken (new is picked up in xrect_return) +* +* \retval -10 Grouping the two rects is possible +* +*/ +static int rmdCollideRects( const XRectangle *xrect1, + const XRectangle *xrect2, + XRectangle xrect_return[], + int *nrects) { + if ((xrect1->x>=xrect2->x)&& + (xrect1->x+xrect1->width<=xrect2->x+xrect2->width)&& + (xrect1->y>=xrect2->y)&& + (xrect1->y+xrect1->height<=xrect2->y+xrect2->height)) { + //1 fits in 2 + *nrects=0; + return 1; + } else if ((xrect2->x>=xrect1->x)&& + (xrect2->x+xrect2->width<=xrect1->x+xrect1->width)&& + (xrect2->y>=xrect1->y)&& + (xrect2->y+xrect2->height<=xrect1->y+xrect1->height)) { + //2 fits in 1 + *nrects=0; + return 2; + } else if ((xrect1->x+xrect1->width<xrect2->x)|| + (xrect2->x+xrect2->width<xrect1->x)|| + (xrect1->y+xrect1->height<xrect2->y)|| + (xrect2->y+xrect2->height<xrect1->y)) { + //no collision + *nrects=0; + return 0; + } else { +//overlapping points are considered enclosed +//this happens because libxdamage may generate many events for one change +//and some of them may be in the the exact same region +//so identical rects would be considered not colliding +//in order though to avoid endless recursion on the rmdRectInsert +//function should always start at the next element(which is logical since +//if any rect makes it to a points none of it's part collides with previous +//nodes on the list, too) + int x1[2]={xrect1->x,xrect1->x+xrect1->width}; + int y1[2]={xrect1->y,xrect1->y+xrect1->height}; + int x2[2]={xrect2->x,xrect2->x+xrect2->width}; + int y2[2]={xrect2->y,xrect2->y+xrect2->height}; + int enclosed[2][4],tot1,tot2; + enclosed[0][0]=(((x1[0]>=x2[0])&&(x1[0]<=x2[1])&& + (y1[0]>=y2[0])&&(y1[0]<=y2[1]))?1:0); + enclosed[0][1]=(((x1[1]>=x2[0])&&(x1[1]<=x2[1])&& + (y1[0]>=y2[0])&&(y1[0]<=y2[1]))?1:0); + enclosed[0][2]=(((x1[0]>=x2[0])&&(x1[0]<=x2[1])&& + (y1[1]>=y2[0])&&(y1[1]<=y2[1]))?1:0); + enclosed[0][3]=(((x1[1]>=x2[0])&&(x1[1]<=x2[1])&& + (y1[1]>=y2[0])&&(y1[1]<=y2[1]))?1:0); + enclosed[1][0]=(((x2[0]>=x1[0])&&(x2[0]<=x1[1])&& + (y2[0]>=y1[0])&&(y2[0]<=y1[1]))?1:0); + enclosed[1][1]=(((x2[1]>=x1[0])&&(x2[1]<=x1[1])&& + (y2[0]>=y1[0])&&(y2[0]<=y1[1]))?1:0); + enclosed[1][2]=(((x2[0]>=x1[0])&&(x2[0]<=x1[1])&& + (y2[1]>=y1[0])&&(y2[1]<=y1[1]))?1:0); + enclosed[1][3]=(((x2[1]>=x1[0])&&(x2[1]<=x1[1])&& + (y2[1]>=y1[0])&&(y2[1]<=y1[1]))?1:0); + tot1=enclosed[0][0]+enclosed[0][1]+enclosed[0][2]+enclosed[0][3]; + tot2=enclosed[1][0]+enclosed[1][1]+enclosed[1][2]+enclosed[1][3]; + if ((tot1==2)&&(tot2==2)) {//same width or height, which is the best case + //group + if ((enclosed[1][0]&&enclosed[1][1])&& + (xrect1->width==xrect2->width)) { + *nrects=1; + xrect_return[0].x = xrect1->x; + xrect_return[0].y = xrect1->y; + xrect_return[0].width = xrect1->width; + xrect_return[0].height = xrect2->height + xrect2->y - xrect1->y; + return -10; + } else if ((enclosed[1][0]&&enclosed[1][2])&& + (xrect1->height==xrect2->height)) { + *nrects=1; + xrect_return[0].x = xrect1->x; + xrect_return[0].y = xrect1->y; + xrect_return[0].width = xrect2->width + xrect2->x - xrect1->x; + xrect_return[0].height = xrect1->height; + return -10; + } else if ((enclosed[1][3]&&enclosed[1][1])&& + (xrect1->height==xrect2->height)) { + *nrects=1; + xrect_return[0].x = xrect2->x; + xrect_return[0].y = xrect2->y; + xrect_return[0].width = xrect1->width + xrect1->x - xrect2->x; + xrect_return[0].height = xrect2->height; + return -10; + } else if ((enclosed[1][3]&&enclosed[1][2])&& + (xrect1->width==xrect2->width)) { + *nrects=1; + xrect_return[0].x = xrect2->x; + xrect_return[0].y = xrect2->y; + xrect_return[0].width = xrect2->width; + xrect_return[0].height = xrect1->height + xrect1->y - xrect2->y; + return -10; + } + //if control reaches here therewasn't a group and we go on + } + + if (tot2==2) { + //break rect2 + xrect_return[0].x = xrect2->x; + xrect_return[0].y = xrect2->y; + xrect_return[0].width = xrect2->width; + xrect_return[0].height = xrect2->height; + *nrects=1; + if (enclosed[1][0]&&enclosed[1][1]) { + xrect_return[0].y = y1[1]; + xrect_return[0].height -= y1[1] - y2[0]; + } else if (enclosed[1][0]&&enclosed[1][2]) { + xrect_return[0].x = x1[1]; + xrect_return[0].width -= x1[1] - x2[0]; + } else if (enclosed[1][3]&&enclosed[1][1]) + xrect_return[0].width -= x2[1] - x1[0]; + else if (enclosed[1][3]&&enclosed[1][2]) + xrect_return[0].height -= y2[1] - y1[0]; + return -2; + } else if (tot1==2) { + //if the first one breaks(which is already inserted) + //then we reenter the part that was left and the one + //that was to be inserted + xrect_return[1].x = xrect2->x; + xrect_return[1].y = xrect2->y; + xrect_return[1].width = xrect2->width; + xrect_return[1].height = xrect2->height; + xrect_return[0].x = xrect1->x; + xrect_return[0].y = xrect1->y; + xrect_return[0].width = xrect1->width; + xrect_return[0].height = xrect1->height; + *nrects=1; + if (enclosed[0][0]&&enclosed[0][1]) { + xrect_return[0].y = y2[1]; + xrect_return[0].height -= y2[1] - y1[0]; + } else if (enclosed[0][0]&&enclosed[0][2]) { + xrect_return[0].x = x2[1]; + xrect_return[0].width -= x2[1] - x1[0]; + } else if (enclosed[0][3]&&enclosed[0][1]) + xrect_return[0].width -= x1[1] - x2[0]; + else if (enclosed[0][3]&&enclosed[0][2]) + xrect_return[0].height -= y1[1] - y2[0]; + return -1; + + } else if (tot2==1) { //in which case there is also tot1==1 + //but we rather not break that + //break rect2 in two + *nrects=2; + if (enclosed[1][0]) { +//first + xrect_return[0].x = x1[1]; + xrect_return[0].y = y2[0]; + xrect_return[0].width = xrect2->width - x1[1] + x2[0]; + xrect_return[0].height = xrect2->height; +//second + xrect_return[1].x = x2[0]; + xrect_return[1].y = y1[1]; + xrect_return[1].width = x1[1] - x2[0]; + xrect_return[1].height = xrect2->height - y1[1] + y2[0]; + } else if (enclosed[1][1]) { +//first + xrect_return[0].x = x2[0]; + xrect_return[0].y = y2[0]; + xrect_return[0].width = xrect2->width - x2[1] + x1[0]; + xrect_return[0].height = xrect2->height; +//second + xrect_return[1].x = x1[0]; + xrect_return[1].y = y1[1]; + xrect_return[1].width = x2[1] - x1[0]; + xrect_return[1].height = xrect2->height - y1[1] + y2[0]; + } else if (enclosed[1][2]) { +//first(same as [1][0]) + xrect_return[0].x = x1[1]; + xrect_return[0].y = y2[0]; + xrect_return[0].width = xrect2->width - x1[1] + x2[0]; + xrect_return[0].height = xrect2->height; +//second + xrect_return[1].x = x2[0]; + xrect_return[1].y = y2[0]; + xrect_return[1].width = x1[1] - x2[0]; + xrect_return[1].height = xrect2->height - y2[1] + y1[0]; + } else if (enclosed[1][3]) { +//first(same as [1][1]) + xrect_return[0].x = x2[0]; + xrect_return[0].y = y2[0]; + xrect_return[0].width = xrect2->width - x2[1] + x1[0]; + xrect_return[0].height = xrect2->height; +//second + xrect_return[1].x = x1[0]; + xrect_return[1].y = y2[0]; + xrect_return[1].width = x2[1] - x1[0]; + xrect_return[1].height = xrect2->height - y2[1] + y1[0]; + } + return -2; + } else {//polygons collide but no point of one is in the other + //so we just keep the two parts of rect2 that are outside rect1 + + //break rect2 in two + //two cases: + //rect2 crossing vertically rect1 + //and rect2 crossing horizontally rect1 + //The proper one can be found by simply checking x,y positions + *nrects=2; + if (xrect2->y<xrect1->y) { + //common + xrect_return[0].x = xrect_return[1].x = x2[0]; + xrect_return[0].width = xrect_return[1].width = xrect2->width; + + xrect_return[0].y = y2[0]; + xrect_return[0].height = xrect2->height - y2[1] + y1[0]; + xrect_return[1].y = y1[1]; + xrect_return[1].height = y2[1] - y1[1]; + } else { + //common + xrect_return[0].y = xrect_return[1].y = y2[0]; + xrect_return[0].height = xrect_return[1].height = xrect2->height; + + xrect_return[0].x = x2[0]; + xrect_return[0].width = xrect2->width - x2[1] + x1[0]; + xrect_return[1].x = x1[1]; + xrect_return[1].width = x2[1] - x1[1]; + } + return -2; + } + } +} + +int rmdRectInsert(RectArea **root, const XRectangle *xrect) { + + int total_insertions = 0; + RectArea *temp = NULL, *newnode = (RectArea *)malloc(sizeof(RectArea)); + + newnode->rect.x = xrect->x; + newnode->rect.y = xrect->y; + newnode->rect.width = xrect->width; + newnode->rect.height = xrect->height; + newnode->prev = newnode->next = NULL; + + if (*root == NULL) { + *root = newnode; + total_insertions = 1; + } else { + XRectangle xrect_return[2]; + int nrects = 0, insert_ok = 1, i = 0; + + temp = *root; + + while (insert_ok) { //if something is broken list does not procceed + //(except on -1 collres case) + + int collres = rmdCollideRects(&temp->rect, xrect, &xrect_return[0], &nrects); + if ((!collres)) + insert_ok = 1; + else { + insert_ok=0; + switch (collres) { + case 1://remove current node,reinsert new one + total_insertions--; + if (temp->prev!=NULL) {//no root + if (temp->next!=NULL) {// + RectArea *temp1=temp->next; + temp->prev->next=temp->next; + temp->next->prev=temp->prev; + free(temp); + if ((xrect->width>0)&&(xrect->height>0)) + total_insertions+=rmdRectInsert(&temp1,xrect); + } else { + temp->prev->next=newnode; + newnode->prev=temp->prev; + total_insertions++; + free(temp); + } + } else {//root + if ((*root)->next!=NULL) { + (*root)=(*root)->next; + (*root)->prev=NULL; + if ((xrect->width>0)&&(xrect->height>0)) + total_insertions+=rmdRectInsert(root,xrect); + } else if ((xrect->width>0)&&(xrect->height>0)) { + *root=newnode; + total_insertions++; + } else { + *root=NULL; + total_insertions++; + } + free(temp); + } + break; + case 2://done,area is already covered + free(newnode); + break; + case -1://current node is broken and reinserted + //(in same pos) + //newnode is also reinserted + if (xrect_return[0].width > 0 && + xrect_return[0].height > 0) { + temp->rect.x = xrect_return[0].x; + temp->rect.y = xrect_return[0].y; + temp->rect.width = xrect_return[0].width; + temp->rect.height = xrect_return[0].height; + if (temp->next==NULL) { + temp->next=newnode; + newnode->prev=temp; + total_insertions++; + } else { + insert_ok=1; + } + } else {//it might happen that the old and now broken node + //is of zero width or height + //(so it isn't reinserted) + if ((temp->prev==NULL)&&(temp->next!=NULL)) { + *root=(*root)->next; + (*root)->prev=NULL; + } else if ((temp->next==NULL)&&(temp->prev!=NULL)) { + temp->prev->next=newnode; + newnode->prev=temp->prev; + } else if ((temp->next==NULL)&&(temp->prev==NULL)) + (*root)=newnode; else { + total_insertions--; + temp->next->prev=temp->prev; + temp->prev->next=temp->next; + total_insertions+=rmdRectInsert(&temp->next, xrect); + } + free(temp); + } + break; + case -2://new is broken and reinserted + if (temp->next==NULL) { + total_insertions+=nrects; + newnode->rect.x = xrect_return[0].x; + newnode->rect.y = xrect_return[0].y; + newnode->rect.width = xrect_return[0].width; + newnode->rect.height = xrect_return[0].height; + temp->next=newnode; + newnode->prev=temp; + if (nrects>1) { + RectArea *newnode1= + (RectArea *)malloc(sizeof(RectArea)); + + newnode1->rect.x = xrect_return[1].x; + newnode1->rect.y = xrect_return[1].y; + newnode1->rect.width = xrect_return[1].width; + newnode1->rect.height = xrect_return[1].height; + newnode->next=newnode1; + newnode1->prev=newnode; + newnode1->next=NULL; + } + } else { + for(i=0;i<nrects;i++) { + if (xrect_return[i].width > 0 && + xrect_return[i].height > 0) + total_insertions+= + rmdRectInsert(&temp->next, &xrect_return[i]); + } + } + break; + case -10://grouped + if (temp->prev==NULL) { + if (temp->next==NULL) {//empty list + newnode->rect.x = xrect_return[0].x; + newnode->rect.y = xrect_return[0].y; + newnode->rect.width = xrect_return[0].width; + newnode->rect.height = xrect_return[0].height; + + *root=newnode; + free(temp); + } else { + total_insertions--; + *root=temp->next; + (*root)->prev=NULL; + free(temp); + if (xrect_return[0].width > 0 && + xrect_return[0].height > 0) + total_insertions+= + rmdRectInsert(root, &xrect_return[0]); + } + } else if (temp->next==NULL) {//last, enter anyway + newnode->rect.x = xrect_return[0].x; + newnode->rect.y = xrect_return[0].y; + newnode->rect.width = xrect_return[0].width; + newnode->rect.height = xrect_return[0].height; + temp->prev->next=newnode; + newnode->prev=temp->prev; + free(temp); + } else {//remove node and reinsert, starting where we were + total_insertions--; + RectArea *temp1=temp->next; + temp->prev->next=temp->next; + temp->next->prev=temp->prev; + free(temp); + if (xrect_return[0].width > 0 && + xrect_return[0].height > 0) + total_insertions+= + rmdRectInsert(&temp1, &xrect_return[0]); + } + break; + } + } + if (insert_ok) { + if (temp->next==NULL) { + temp->next=newnode; + newnode->prev=temp; + total_insertions++; + break; + } else { + temp=temp->next; + } + } else { + break; + } + }; + } + return total_insertions; +} + +void rmdClearList(RectArea **root) { + + RectArea *temp; + temp=*root; + if (temp!=NULL) { + while (temp->next!=NULL) { + temp=temp->next; + free(temp->prev); + } + free(temp); + *root=NULL; + } +} diff --git a/src/rmd_rectinsert.h b/src/rmd_rectinsert.h new file mode 100644 index 0000000..d9d0a9c --- /dev/null +++ b/src/rmd_rectinsert.h @@ -0,0 +1,55 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef RECTINSERT_H +#define RECTINSERT_H 1 + + +#include "rmd_types.h" + + +/** +* Insert a new rectangle on the list, making sure it doesn't overlap +* with the existing ones +* \param root Root entry of the list +* +* \param xrect New area to be inserted +* +* \returns Number of insertions during operation +* +* \note This function is reentrant and recursive. The number +* of insertions takes this into account. +*/ +int rmdRectInsert(RectArea **root, const XRectangle *xrect); + +/** +* Clean up a list of areas marked for update. +* \param root Root entry of the list +*/ +void rmdClearList(RectArea **root); + + +#endif diff --git a/src/rmd_register_callbacks.c b/src/rmd_register_callbacks.c new file mode 100644 index 0000000..33e04dd --- /dev/null +++ b/src/rmd_register_callbacks.c @@ -0,0 +1,86 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_register_callbacks.h" + +#include "rmd_types.h" + +#include <signal.h> + + +// There seem to be no way of passing user data to the signal handler, +// so hack around not being able to pass ProgData to them +static int *pdata_running = NULL; +static int *pdata_paused = NULL; +static int *pdata_aborted = NULL; +static int *pdata_pause_state_changed = NULL; + + +static void rmdSetPaused(int signum) { + + *pdata_pause_state_changed = TRUE; +} + +static void rmdSetRunning(int signum) { + + if (!*pdata_paused) { + + *pdata_running = FALSE; + + if (signum == SIGABRT) { + *pdata_aborted = TRUE; + } + } +} + +void rmdRegisterCallbacks(ProgData *pdata) { + + struct sigaction pause_act; + struct sigaction end_act; + + // Is there some way to pass pdata to the signal handlers? + pdata_running = &pdata->running; + pdata_paused = &pdata->paused; + pdata_aborted = &pdata->aborted; + pdata_pause_state_changed = &pdata->pause_state_changed; + + // Setup pause_act + sigfillset(&pause_act.sa_mask); + pause_act.sa_flags = SA_RESTART; + pause_act.sa_handler = rmdSetPaused; + + sigaction(SIGUSR1, &pause_act, NULL); + + // Setup end_act + sigfillset(&end_act.sa_mask); + end_act.sa_flags = SA_RESTART; + end_act.sa_handler = rmdSetRunning; + + sigaction(SIGINT, &end_act, NULL); + sigaction(SIGTERM, &end_act, NULL); + sigaction(SIGABRT, &end_act, NULL); +} diff --git a/src/rmd_register_callbacks.h b/src/rmd_register_callbacks.h new file mode 100644 index 0000000..abe8783 --- /dev/null +++ b/src/rmd_register_callbacks.h @@ -0,0 +1,41 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef REGISTER_CALLBACKS_H +#define REGISTER_CALLBACKS_H 1 + + +#include "rmd_types.h" + + +/** +* Set up all callbacks and signal handlers +* \param pdata ProgData struct containing all program data +*/ +void rmdRegisterCallbacks(ProgData *prog_data); + + +#endif diff --git a/src/rmd_rescue.c b/src/rmd_rescue.c new file mode 100644 index 0000000..84bcf4b --- /dev/null +++ b/src/rmd_rescue.c @@ -0,0 +1,124 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_rescue.h" + +#include "rmd_yuv_utils.h" +#include "rmd_encode_cache.h" +#include "rmd_initialize_data.h" +#include "rmd_register_callbacks.h" +#include "rmd_specsfile.h" +#include "rmd_types.h" + +#include <pthread.h> + +#include <string.h> +#include <stdlib.h> + + +int rmdRescue(const char *path) { + unsigned short width, height; + ProgData pdata; + EncData enc_data; + CacheData cache_data; + + rmdSetupDefaultArgs(&pdata.args); + + pdata.enc_data = &enc_data; + pdata.cache_data = &cache_data; + + //projname + cache_data.projname = malloc(strlen(path) + 2); + strcpy(cache_data.projname, path); + strcat(cache_data.projname, "/");//having two of these doesn't hurt... + //image data + cache_data.imgdata = malloc(strlen(cache_data.projname) + 11); + strcpy(cache_data.imgdata, cache_data.projname); + strcat(cache_data.imgdata, "img.out"); + //audio data + cache_data.audiodata = malloc(strlen(cache_data.projname) + 10); + strcpy(cache_data.audiodata, cache_data.projname); + strcat(cache_data.audiodata, "audio.pcm"); + //specsfile + cache_data.specsfile = malloc(strlen(cache_data.projname) + 10); + strcpy(cache_data.specsfile, cache_data.projname); + strcat(cache_data.specsfile, "specs.txt"); + + if (rmdReadSpecsFile(&pdata)) + return 1; + + width = ((pdata.brwin.rrect.width + 15) >> 4) << 4; + height = ((pdata.brwin.rrect.height + 15) >> 4) << 4; + + enc_data.yuv.y = malloc(height * width); + enc_data.yuv.u = malloc(height * width / 4); + enc_data.yuv.v = malloc(height * width / 4); + enc_data.yuv.y_width = width; + enc_data.yuv.y_height = height; + enc_data.yuv.y_stride = width; + + enc_data.yuv.uv_width = width / 2; + enc_data.yuv.uv_height = height / 2; + enc_data.yuv.uv_stride = width / 2; + + for (int i = 0; i < (enc_data.yuv.y_width * enc_data.yuv.y_height); i++) + enc_data.yuv.y[i] = 0; + + for (int i = 0; i < (enc_data.yuv.uv_width * enc_data.yuv.uv_height); i++) + enc_data.yuv.v[i] = enc_data.yuv.u[i] = 127; + + yblocks = malloc(sizeof(*yblocks) * (enc_data.yuv.y_width / Y_UNIT_WIDTH) * + (enc_data.yuv.y_height / Y_UNIT_WIDTH)); + ublocks = malloc(sizeof(*ublocks) * (enc_data.yuv.y_width / Y_UNIT_WIDTH) * + (enc_data.yuv.y_height / Y_UNIT_WIDTH)); + vblocks = malloc(sizeof(*vblocks) * (enc_data.yuv.y_width / Y_UNIT_WIDTH) * + (enc_data.yuv.y_height / Y_UNIT_WIDTH)); + + pdata.frametime = 1000000 / pdata.args.fps; + + pthread_mutex_init(&pdata.theora_lib_mutex, NULL); + pthread_mutex_init(&pdata.vorbis_lib_mutex, NULL); + pthread_mutex_init(&pdata.libogg_mutex, NULL); + pthread_cond_init(&pdata.theora_lib_clean, NULL); + pthread_cond_init(&pdata.vorbis_lib_clean, NULL); + pdata.th_encoding_clean = pdata.v_encoding_clean = 1; + pdata.avd = 0; + pdata.sound_buffer = NULL; + pdata.running = TRUE; + pdata.aborted = FALSE; + + rmdRegisterCallbacks(&pdata); + fprintf(stderr, "Restoring %s!!!\n", path); + + rmdEncodeCache(&pdata); + + fprintf(stderr, "Done!!!\n"); + fprintf(stderr, "Goodbye!\n"); + rmdCleanUp(); + + return 0; +} diff --git a/src/rmd_rescue.h b/src/rmd_rescue.h new file mode 100644 index 0000000..2fbf2da --- /dev/null +++ b/src/rmd_rescue.h @@ -0,0 +1,42 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef RMD_RESCUE_H +#define RMD_RESCUE_H 1 + +/* + * Rescue a previous recording, found in + * the given path. + * + * \param path Path to the cache folder. + * + * \returns 0 on Success, 1 on failure + * + */ +int rmdRescue(const char *path); + + +#endif diff --git a/src/rmd_setbrwindow.c b/src/rmd_setbrwindow.c new file mode 100644 index 0000000..9ad30b8 --- /dev/null +++ b/src/rmd_setbrwindow.c @@ -0,0 +1,115 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_setbrwindow.h" + +#include "rmd_types.h" + + +boolean rmdSetBRWindow( Display *dpy, + BRWindow *brwin, + DisplaySpecs *specs, + ProgArgs *args) { + + //before we start recording we have to make sure the ranges are valid + if (args->windowid == 0) {//root window + //first set it up + brwin->windowid = specs->root; + brwin->winrect.x = 0; + brwin->winrect.y = 0; + brwin->winrect.width = specs->width; + brwin->winrect.height = specs->height; + + brwin->rrect.x = args->x; + brwin->rrect.y = args->y; + brwin->rrect.width = args->width ? args->width : brwin->winrect.width - args->x; + brwin->rrect.height = args->height ? args->height : brwin->winrect.height - args->y; + + //and then check validity + if ( brwin->rrect.x + brwin->rrect.width > specs->width || + brwin->rrect.y + brwin->rrect.height > specs->height) { + + fprintf(stderr, "Window size specification out of bounds!" + "(current resolution:%dx%d)\n", + specs->width, specs->height); + return FALSE; + } + } else { + int transl_x, transl_y; + Window wchid; + XWindowAttributes attribs; + + XGetWindowAttributes(dpy, args->windowid, &attribs); + + if (attribs.map_state == IsUnviewable || attribs.map_state == IsUnmapped) { + fprintf(stderr, "Window must be mapped and visible!\n"); + return FALSE; + } + + XTranslateCoordinates( dpy, + specs->root, + args->windowid, + attribs.x, + attribs.y, + &transl_x, + &transl_y, + &wchid); + + brwin->winrect.x = attribs.x - transl_x; + brwin->winrect.y = attribs.y - transl_y; + brwin->winrect.width = attribs.width; + brwin->winrect.height = attribs.height; + + /* XXX FIXME: this check is partial at best, surely windows can be off the low + * sides of the screen too... + */ + if ( brwin->winrect.x + brwin->winrect.width > specs->width || + brwin->winrect.y + brwin->winrect.height > specs->height) { + + fprintf(stderr,"Window must be on visible screen area!\n"); + return FALSE; + } + + brwin->rrect.x = brwin->winrect.x + args->x; + brwin->rrect.y = brwin->winrect.y + args->y; + brwin->rrect.width = args->width ? args->width : brwin->winrect.width - args->x; + brwin->rrect.height = args->height ? args->height : brwin->winrect.height - args->y; + + if ( args->x + brwin->rrect.width > brwin->winrect.width || + args->y + brwin->rrect.height > brwin->winrect.height) { + fprintf(stderr, "Specified Area is larger than window!\n"); + return FALSE; + } + } + + fprintf(stderr, "Initial recording window is set to:\n" + "X:%d Y:%d Width:%d Height:%d\n", + brwin->rrect.x, brwin->rrect.y, + brwin->rrect.width, brwin->rrect.height); + + return TRUE; +} diff --git a/src/rmd_setbrwindow.h b/src/rmd_setbrwindow.h new file mode 100644 index 0000000..e036856 --- /dev/null +++ b/src/rmd_setbrwindow.h @@ -0,0 +1,53 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef SETBRWINDOW_H +#define SETBRWINDOW_H 1 + +#include "rmd_types.h" + + +/** +* Check and align window size +* +* \param dpy Connection to the server +* +* \param brwin BRWindow struct contaning the initial and final window +* +* \param specs DisplaySpecs struct with +* information about the display to be recorded +* +* \param args ProgArgs struct containing the user-set options +* +* \returns 0 on Success 1 on Failure +*/ +int rmdSetBRWindow(Display *dpy, + BRWindow *brwin, + DisplaySpecs *specs, + ProgArgs *args); + + +#endif diff --git a/src/rmd_shortcuts.c b/src/rmd_shortcuts.c new file mode 100644 index 0000000..e1e07f5 --- /dev/null +++ b/src/rmd_shortcuts.c @@ -0,0 +1,142 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_shortcuts.h" + +#include "rmd_types.h" + +#include <X11/Xlib.h> +#include <X11/Xlibint.h> +#include <X11/keysym.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +int rmdRegisterShortcut( Display *dpy, + Window root, + const char *shortcut, + HotKey *hotkey) { + + int keycode = 0, i, j; + KeySym key = 0; + unsigned int modifier_mask = 0, numlock_mask = 0; + char *keystr = NULL; + + if (strstr(shortcut, "Shift")) + modifier_mask = modifier_mask | ShiftMask; + if (strstr(shortcut, "Control")) + modifier_mask = modifier_mask | ControlMask; + if (strstr(shortcut, "Mod1")) + modifier_mask = modifier_mask | Mod1Mask; + if (strstr(shortcut, "Mod2")) + modifier_mask = modifier_mask | Mod2Mask; + if (strstr(shortcut, "Mod3")) + modifier_mask = modifier_mask | Mod3Mask; + if (strstr(shortcut, "Mod4")) + modifier_mask = modifier_mask | Mod4Mask; + if (strstr(shortcut, "Mod5")) + modifier_mask = modifier_mask | Mod5Mask; + + //we register the shortcut on the root + //window, which means on every keypress event, + //so I think it's neccessary to have at least one + //modifier. + if (modifier_mask == 0) + return 1; + if ((keystr = rindex(shortcut, '+')) != NULL) { + keystr++; + if ((key = XStringToKeysym(keystr)) == NoSymbol) + return 1; + else + keycode = XKeysymToKeycode(dpy, key); + } else + return 1; + + + /* Key grabbing stuff taken from tilda who took it from yeahconsole + * who took it from evilwm */ + + { + KeyCode numlock = XKeysymToKeycode(dpy, XK_Num_Lock); + XModifierKeymap *modmap = XGetModifierMapping(dpy); + for (i = 0; i < 8; i++) { + for (j = 0; j < modmap->max_keypermod; j++) { + if (modmap->modifiermap[i * modmap->max_keypermod + j] == numlock) + numlock_mask = (1 << i); + } + } + XFreeModifiermap(modmap); + } + + hotkey->modnum = 0; + hotkey->key = keycode; + + XGrabKey( dpy, + keycode, + modifier_mask, + root, + True, + GrabModeAsync, + GrabModeAsync); + hotkey->mask[0] = modifier_mask; + hotkey->modnum++; + + XGrabKey( dpy, + keycode, + LockMask | modifier_mask, + root, + True, + GrabModeAsync, + GrabModeAsync); + hotkey->mask[1] = LockMask | modifier_mask; + hotkey->modnum++; + + if (numlock_mask) { + XGrabKey( dpy, + keycode, + numlock_mask | modifier_mask, + root, + True, + GrabModeAsync, + GrabModeAsync); + hotkey->mask[2] = numlock_mask | modifier_mask; + hotkey->modnum++; + + XGrabKey( dpy, + keycode, + numlock_mask | LockMask | modifier_mask, + root, + True, + GrabModeAsync, + GrabModeAsync); + hotkey->mask[3] = numlock_mask | LockMask | modifier_mask; + hotkey->modnum++; + } + + return 0; +} diff --git a/src/rmd_shortcuts.h b/src/rmd_shortcuts.h new file mode 100644 index 0000000..a0dc2af --- /dev/null +++ b/src/rmd_shortcuts.h @@ -0,0 +1,57 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef SHORTCUTS_H +#define CHORTCUTS_H 1 + +#include "rmd_types.h" + + +/* + * Check a shortcut combination and if valid, + * register it, on the root window. + * + * \param dpy Connection to the X Server + * + * \param root Root window id + * + * \param shortcut String represantation of the shortcut + * + * \param HotKey Pre-allocated struct that is filled with the + * modifiers and the keycode, for checks on incoming + * keypress events. Left untouched if the call fails. + * + * + * \returns 0 on Success, 1 on Failure. + * + */ +int rmdRegisterShortcut(Display *dpy, + Window root, + const char *shortcut, + HotKey *hotkey); + + +#endif diff --git a/src/rmd_specsfile.c b/src/rmd_specsfile.c new file mode 100644 index 0000000..50542a8 --- /dev/null +++ b/src/rmd_specsfile.c @@ -0,0 +1,151 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_specsfile.h" + +#include "rmd_types.h" + +#include <stdlib.h> +#include <stdio.h> + + +int rmdWriteSpecsFile(ProgData *pdata) { + + FILE *fp; + + fp=fopen(pdata->cache_data->specsfile,"wb"); + if (!fp) + return 1; + + fprintf(fp,"recordMyDesktop = %s\n",VERSION); + fprintf(fp,"Width = %hu\n",pdata->brwin.rrect.width); + fprintf(fp,"Height = %hu\n",pdata->brwin.rrect.height); + fprintf(fp,"Filename = %s\n",pdata->args.filename); + fprintf(fp,"FPS = %f\n",pdata->args.fps); + fprintf(fp,"NoSound = %d\n",pdata->args.nosound); + fprintf(fp,"Frequency = %d\n",pdata->args.frequency); + fprintf(fp,"Channels = %d\n",pdata->args.channels); + fprintf(fp,"BufferSize = %lu\n",(unsigned long)pdata->args.buffsize); + fprintf(fp,"SoundFrameSize = %d\n",pdata->sound_framesize); + fprintf(fp,"PeriodSize = %lu\n",(unsigned long)pdata->periodsize); + fprintf(fp,"UsedJack = %d\n",pdata->args.use_jack); + fprintf(fp,"v_bitrate = %d\n",pdata->args.v_bitrate); + fprintf(fp,"v_quality = %d\n",pdata->args.v_quality); + fprintf(fp,"s_quality = %d\n",pdata->args.s_quality); + fprintf(fp,"ZeroCompression = %d\n",pdata->args.zerocompression); + + fclose(fp); + + return 0; +} + +int rmdReadSpecsFile(ProgData *pdata) { + char Cached_Version[256]; + FILE *fp; + + fp=fopen(pdata->cache_data->specsfile,"rb"); + if (!fp) + return 1; + + free(pdata->args.filename); + pdata->args.filename=malloc(512); + + //Take that single-point-of-exit advocates !!! + //15 points of exit, just for your pleasure. + //Also, Vi(m) rules, emacs sucks. + + if (fscanf(fp,"recordMyDesktop = %s\n",Cached_Version)!=1) { + fprintf(stderr,"Error reading VERSION attribute!!!\n"); + return 1; + } + if (fscanf(fp,"Width = %hu\n",&pdata->brwin.rrect.width)!=1) { + fprintf(stderr,"Error reading Width attribute!!!\n"); + return 1; + } + if (fscanf(fp,"Height = %hu\n",&pdata->brwin.rrect.height)!=1) { + fprintf(stderr,"Error reading Height attribute!!!\n"); + return 1; + } + if (fscanf(fp,"Filename = %s\n",pdata->args.filename)!=1) { + fprintf(stderr,"Error reading Filename attribute!!!\n"); + return 1; + } + if (fscanf(fp,"FPS = %f\n",&pdata->args.fps)!=1) { + fprintf(stderr,"Error reading FPS attribute!!!\n"); + return 1; + } + if (fscanf(fp,"NoSound = %d\n",&pdata->args.nosound)!=1) { + fprintf(stderr,"Error reading NoSound attribute!!!\n"); + return 1; + } + if (fscanf(fp,"Frequency = %d\n",&pdata->args.frequency)!=1) { + fprintf(stderr,"Error reading Frequency attribute!!!\n"); + return 1; + } + if (fscanf(fp,"Channels = %d\n",&pdata->args.channels)!=1) { + fprintf(stderr,"Error reading Channels attribute!!!\n"); + return 1; + } + if (fscanf(fp,"BufferSize = %lu\n", + (unsigned long *)&pdata->args.buffsize)!=1) { + fprintf(stderr,"Error reading BufferSize attribute!!!\n"); + return 1; + } + if (fscanf(fp,"SoundFrameSize = %d\n",&pdata->sound_framesize)!=1) { + fprintf(stderr,"Error reading SoundFrameSize attribute!!!\n"); + return 1; + } + if (fscanf(fp,"PeriodSize = %lu\n", + (unsigned long *)&pdata->periodsize)!=1) { + fprintf(stderr,"Error reading PeriodSize attribute!!!\n"); + return 1; + } + if (fscanf(fp,"UsedJack = %u\n",&pdata->args.use_jack)!=1) { + fprintf(stderr,"Error reading UsedJack attribute!!!\n"); + return 1; + } + if (fscanf(fp,"v_bitrate = %d\n",&pdata->args.v_bitrate)!=1) { + fprintf(stderr,"Error reading v_bitrate attribute!!!\n"); + return 1; + } + if (fscanf(fp,"v_quality = %d\n",&pdata->args.v_quality)!=1) { + fprintf(stderr,"Error reading v_quality attribute!!!\n"); + return 1; + } + if (fscanf(fp,"s_quality = %d\n",&pdata->args.s_quality)!=1) { + fprintf(stderr,"Error reading s_quality attribute!!!\n"); + return 1; + } + if (fscanf(fp,"ZeroCompression = %d\n",&pdata->args.zerocompression)!=1) { + fprintf(stderr,"Error reading ZeroCompression attribute!!!\n"); + return 1; + } + + fclose(fp); + + return 0; +} diff --git a/src/rmd_specsfile.h b/src/rmd_specsfile.h new file mode 100644 index 0000000..67cbd46 --- /dev/null +++ b/src/rmd_specsfile.h @@ -0,0 +1,59 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef SPECSFILE_H +#define SPECSFILE_H 1 + +#include "rmd_types.h" + + +/* + * Create a text file that holds the required + * capture attributes, in the cache directory. + * + * \param pdata ProgData struct containing all program data + * + * \returns 0 on Success, 1 on failure + * + */ +int rmdWriteSpecsFile(ProgData *pdata); + + + +/* + * Read the text file that holds the required + * capture attributes, in the cache directory. + * + * \param pdata ProgData struct that will be fille + * with all program data + * + * \returns 0 on Success, 1 on failure + * + */ +int rmdReadSpecsFile(ProgData *pdata); + + +#endif diff --git a/src/rmd_threads.c b/src/rmd_threads.c new file mode 100644 index 0000000..cb81f84 --- /dev/null +++ b/src/rmd_threads.c @@ -0,0 +1,169 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_threads.h" + +#include "rmd_cache_audio.h" +#include "rmd_cache_frame.h" +#include "rmd_capture_sound.h" +#include "rmd_encode_image_buffer.h" +#include "rmd_encode_sound_buffer.h" +#include "rmd_flush_to_ogg.h" +#include "rmd_get_frame.h" +#include "rmd_jack.h" +#include "rmd_register_callbacks.h" +#include "rmd_timer.h" +#include "rmd_types.h" + +#include <pthread.h> + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> + +void rmdThreads(ProgData *pdata) { + pthread_t image_capture_t, + image_encode_t, + image_cache_t, + sound_capture_t, + sound_encode_t, + sound_cache_t, + flush_to_ogg_t, + timer_t; + + if (pdata->args.delay > 0) { + fprintf(stderr, "Will sleep for %d seconds now.\n", pdata->args.delay); + sleep(pdata->args.delay); + } + + /*start threads*/ + pthread_create( &image_capture_t, + NULL, + (void *)rmdGetFrame, + (void *)pdata); + + if (pdata->args.encOnTheFly) + pthread_create( &image_encode_t, + NULL, + (void *)rmdEncodeImageBuffer, + (void *)pdata); + else + pthread_create( &image_cache_t, + NULL, + (void *)rmdCacheImageBuffer, + (void *)pdata); + + if (!pdata->args.nosound) { + if (!pdata->args.use_jack) + pthread_create( &sound_capture_t, + NULL, + (void *)rmdCaptureSound, + (void *)pdata); + + if (pdata->args.encOnTheFly) + pthread_create( &sound_encode_t, + NULL, + (void *)rmdEncodeSoundBuffer, + (void *)pdata); + else + pthread_create( &sound_cache_t, + NULL, + (void *)rmdCacheSoundBuffer, + (void *)pdata); + } + + if (pdata->args.encOnTheFly) + pthread_create( &flush_to_ogg_t, + NULL, + (void *)rmdFlushToOgg, + (void *)pdata); + + rmdRegisterCallbacks(pdata); + pdata->timer_alive = 1; + pthread_create( &timer_t, + NULL, + (void *)rmdTimer, + (void *)pdata); + fprintf(stderr,"Capturing!\n"); + +#ifdef HAVE_LIBJACK + if (pdata->args.use_jack) + pdata->jdata->capture_started = 1; +#endif + //wait all threads to finish + + pthread_join(image_capture_t, NULL); + fprintf(stderr,"Shutting down."); + //if no damage events have been received the thread will get stuck + pthread_mutex_lock(&pdata->theora_lib_mutex); + while (!pdata->th_encoding_clean) { + puts("waiting for th_enc"); + pthread_cond_signal(&pdata->image_buffer_ready); + pthread_mutex_unlock(&pdata->theora_lib_mutex); + usleep(10000); + pthread_mutex_lock(&pdata->theora_lib_mutex); + } + pthread_mutex_unlock(&pdata->theora_lib_mutex); + + if (pdata->args.encOnTheFly) + pthread_join(image_encode_t, NULL); + else + pthread_join(image_cache_t, NULL); + fprintf(stderr,"."); + + if (!pdata->args.nosound) { +#ifdef HAVE_LIBJACK + if (pdata->args.use_jack) + rmdStopJackClient(pdata->jdata); +#endif + if (!pdata->args.use_jack) + pthread_join(sound_capture_t,NULL); + + fprintf(stderr,"."); + pthread_mutex_lock(&pdata->vorbis_lib_mutex); + while (!pdata->v_encoding_clean) { + puts("waiting for v_enc"); + pthread_cond_signal(&pdata->sound_data_read); + pthread_mutex_unlock(&pdata->vorbis_lib_mutex); + usleep(10000); + pthread_mutex_lock(&pdata->vorbis_lib_mutex); + } + pthread_mutex_unlock(&pdata->vorbis_lib_mutex); + + if (pdata->args.encOnTheFly) + pthread_join(sound_encode_t, NULL); + else + pthread_join(sound_cache_t, NULL); + } else + fprintf(stderr,".."); + + fprintf(stderr,"."); + + //Now that we are done with recording we cancel the timer + pdata->timer_alive = 0; + pthread_join(timer_t,NULL); +} diff --git a/src/rmd_threads.h b/src/rmd_threads.h new file mode 100644 index 0000000..e2c103a --- /dev/null +++ b/src/rmd_threads.h @@ -0,0 +1,43 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef RMDTHREADS_H +#define RMDTHREADS_H 1 + +#include "rmd_types.h" + + +/** +* Launch and wait capture threads. +* Also creates and waits the encoding threads when +* encode-on-the-fly is enabled. +* +* \param pdata ProgData struct containing all program data +*/ +void rmdThreads(ProgData *pdata); + + +#endif diff --git a/src/rmd_timer.c b/src/rmd_timer.c new file mode 100644 index 0000000..b8161ca --- /dev/null +++ b/src/rmd_timer.c @@ -0,0 +1,81 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_timer.h" + +#include "rmd_types.h" + +#include <pthread.h> + +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> + + +void *rmdTimer(ProgData *pdata){ + long unsigned int secs_tw=1/pdata->args.fps; + long unsigned int usecs_tw=(1000000)/pdata->args.fps- secs_tw*1000000; + + while (pdata->timer_alive) { + + pthread_mutex_lock(&pdata->pause_mutex); + if (pdata->pause_state_changed) { + pdata->pause_state_changed = FALSE; + + if (!pdata->paused) { + pdata->paused = TRUE; + fprintf(stderr,"STATE:PAUSED\n");fflush(stderr); + } else{ + pdata->paused = FALSE; + fprintf(stderr,"STATE:RECORDING\n");fflush(stderr); + pthread_cond_broadcast(&pdata->pause_cond); + } + } + + if (!pdata->paused) { + pthread_mutex_unlock(&pdata->pause_mutex); + + /* FIXME TODO: detect dropped frames by delta between {time,capture}_frameno */ + pdata->frames_total++; + } else + pthread_mutex_unlock(&pdata->pause_mutex); + + pthread_mutex_lock(&pdata->time_mutex); + pdata->time_frameno++; + pthread_mutex_unlock(&pdata->time_mutex); + pthread_cond_signal(&pdata->time_cond); + + /* FIXME use nanosleep */ + if (secs_tw) + sleep(secs_tw); + + usleep(usecs_tw); + } + + pthread_exit(&errno); +} diff --git a/src/rmd_timer.h b/src/rmd_timer.h new file mode 100644 index 0000000..d9292d9 --- /dev/null +++ b/src/rmd_timer.h @@ -0,0 +1,44 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef RMD_TIMER_H +#define RMD_TIMER_H 1 + +#include "rmd_types.h" + + +/** +* Loop ,signal timer cond var,sleep-\ +* ^ | +* |________________________________/ +* +* +* \param pdata ProgData struct containing all program data +*/ +void *rmdTimer(ProgData *pdata); + + +#endif diff --git a/src/rmd_types.h b/src/rmd_types.h new file mode 100644 index 0000000..6018955 --- /dev/null +++ b/src/rmd_types.h @@ -0,0 +1,366 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef RMDTYPES_H +#define RMDTYPES_H 1 + +#include "config.h" + +#include <stdio.h> +#include <pthread.h> +#include <zlib.h> +#include <X11/Xlib.h> +#include <X11/extensions/XShm.h> +#include <theora/theora.h> +#include <vorbis/codec.h> +#include <vorbis/vorbisenc.h> +#include <ogg/ogg.h> + +#ifdef HAVE_LIBASOUND + #include <alsa/asoundlib.h> + + #define DEFAULT_AUDIO_DEVICE "hw:0,0" +#else + #include <sys/ioctl.h> + #include <sys/soundcard.h> + + #define DEFAULT_AUDIO_DEVICE "/dev/dsp" +#endif + +#ifdef HAVE_LIBJACK + #include <jack/jack.h> + #include <jack/ringbuffer.h> +#endif + + +//this type exists only +//for comparing the planes at caching. +//u_int64_t mught not be available everywhere. +//The performance gain comes from casting the unsigned char +//buffers to this type before comparing the two blocks. +//This is made possible by the fact that blocks +//for the Y plane are 16 bytes in width and blocks +//for the U,V planes are 8 bytes in width +#ifdef HAVE_U_INT64_T +typedef u_int64_t cmp_int_t; +#else +typedef u_int32_t cmp_int_t; +#endif + +//type of pixel proccessing for the Cb,Cr planes +//when converting from full rgb to 4:2:2 Ycbcr +enum{ + __PXL_DISCARD, //only select 1 pixel in every block of four + __PXL_AVERAGE //calculate the average of all four pixels +}; + +// Boolean type +typedef int boolean; +#ifndef FALSE +#define FALSE (0) +#endif +#ifndef TRUE +#define TRUE (!FALSE) +#endif + +#define RMD_MAX_JACK_PORTS (100) + +// Forward declarations +typedef struct _ProgData ProgData; + +typedef struct _Image { + XImage *ximage; + XShmSegmentInfo shm_info; +}Image; + +typedef struct _DisplaySpecs{ //this struct holds some basic information + int screen; //about the display,needed mostly for + unsigned int width, height; //validity checks at startup + Window root; + Visual *visual; + GC gc; + int depth; +}DisplaySpecs; + +typedef struct _RectArea{ //an area that has been damaged gets stored + XRectangle rect; //in a list comprised of structs of this type + struct _RectArea *prev,*next; +}RectArea; + +typedef struct _BRWindow{ //'basic recorded window' specs + XRectangle winrect; //window attributes + XRectangle rrect; //recorded window rect in screen space coordinates + Window windowid; //id +}BRWindow; + +//defaults in the following comment lines may be out of sync with reality +//check the SetupDefaultArgs() function further bellow +typedef struct _ProgArgs{ + int delay; //start up delay + Window windowid; //window to record(default root) + char *display; //display to connect(default :0) + int x,y; //x,y offset(default 0,0) + int width,height; //defaults to window width and height + char *filename; //output file(default out.[ogg|*]) + int cursor_color; //black or white=>1 or 0 + int have_dummy_cursor; //disable/enable drawing of the dummy cursor + int xfixes_cursor; //disable/enable drawing of a cursor obtained + //through the xfixes extension + float fps; //desired framerate(default 15) + unsigned int frequency; //desired frequency (default 22050) + unsigned int channels; //no of channels(default 2) + char *device; //default sound device +#ifdef HAVE_LIBASOUND + snd_pcm_uframes_t buffsize; //buffer size(in frames) for sound capturing +#else + u_int32_t buffsize; +#endif + const char* rescue_path; + int nosound; //do not record sound(default 0) + int noshared; //do not use shared memory extension(default 0) + int nowmcheck; //do not check if there's a 3d comp window manager + //(which changes full-shots and with-shared to 1) + int full_shots; //do not poll damage, take full screenshots + int follow_mouse; //capture area follows the mouse(fullshots auto enabled) + int no_encode; //do not encode or delete the temporary files(debug opt) + int no_quick_subsample; //average pixels in chroma planes + int v_bitrate,v_quality,s_quality; //video bitrate,video-sound quality + int encOnTheFly; //encode while recording, no caching(default 0) + char *workdir; //directory to be used for cache files(default $HOME) + char *pause_shortcut; //pause/unpause shortcut sequence(Control+Alt+p) + char *stop_shortcut; //stop shortcut sequence(Control+Alt+s) + int noframe; //don't draw a frame around the recording area + int zerocompression; //image data are always flushed uncompressed + int overwrite; //overwite a previously existing file + //(do not add a .number postfix) + int use_jack; //record audio with jack + unsigned int jack_nports; + char *jack_port_names[RMD_MAX_JACK_PORTS]; + float jack_ringbuffer_secs; +} ProgArgs; + +//this struct holds anything related to encoding AND +//writting out to file. +typedef struct _EncData{ + ogg_stream_state m_ogg_ts; //theora + ogg_stream_state m_ogg_vs; //vorbis + ogg_page m_ogg_pg; //this could be avoided since + // it is used only while initializing + ogg_packet m_ogg_pckt1; //theora stream + ogg_packet m_ogg_pckt2; //vorbis stream +//theora data + theora_state m_th_st; + theora_info m_th_inf; + theora_comment m_th_cmmnt; + yuv_buffer yuv; +//vorbis data + vorbis_info m_vo_inf; + vorbis_comment m_vo_cmmnt; + vorbis_dsp_state m_vo_dsp; + vorbis_block m_vo_block; +//our file + FILE *fp; +} EncData; + +//this struct will hold a few basic +//information, needed for caching the frames. +typedef struct _CacheData{ + char *workdir, //The directory were the project + //will be stored, while recording. + //Since this will take a lot of space, the user must be + //able to change the location. + *projname, //This is the name of the folder that + //will hold the project. + //It is rMD-session-%d where %d is the pid + //of the current proccess. + //This way, running two instances + //will not create problems + //and also, a frontend can identify + //leftovers from a possible crash + //and delete them + *specsfile, //workdir+projname+specs.txt + *imgdata, //workdir+projname+img.out.gz + *audiodata; //workdir+projname+audio.pcm + + gzFile ifp; //image data file pointer + FILE *uncifp; //uncompressed image data file pointer + + FILE *afp; //audio data file pointer + +}CacheData; + +//sound buffer +//sound keeps coming so we que it in this list +//which we then traverse +typedef struct _SndBuffer{ + signed char *data; + struct _SndBuffer *next; +}SndBuffer; + +#ifdef HAVE_LIBJACK +typedef struct _JackData{ + ProgData *pdata; //pointer to prog data + jack_client_t *client; + unsigned int buffersize, //buffer size for every port in frames. + frequency, //samplerate with which jack server was started. + nports; //number of ports. + float ringbuffer_secs; + char **port_names; //names of ports(as specified in args). + jack_port_t **ports; //connections to thes ports. + jack_default_audio_sample_t + **portbuf; //retrieval of audio buffers. + pthread_mutex_t *sound_buffer_mutex; //mutex and cond_var + pthread_cond_t *sound_data_read; //in the pdata struct + jack_ringbuffer_t *sound_buffer; //data exchange happens through this + int capture_started; //used to hold recording in the beginning +}JackData; +#endif + +typedef struct _HotKey{ //Hold info about the shortcuts + int modnum; //modnum is the number of modifier masks + unsigned int mask[4]; //that should be checked (the initial + int key; //user requested modifier plus it's +}HotKey; //combinations with LockMask and NumLockMask). + +//this structure holds any data related to the program +//It's usage is mostly to be given as an argument to the +//threads,so they will have access to the program data, avoiding +//at the same time usage of any globals. +struct _ProgData { +/**recordMyDesktop specific structs*/ + ProgArgs args; //the program arguments + DisplaySpecs specs; //Display specific information + BRWindow brwin; //recording window + RectArea *rect_root; //the interchanging list roots for storing + //the changed regions + SndBuffer *sound_buffer; + EncData *enc_data; + CacheData *cache_data; + HotKey pause_key, //Shortcuts + stop_key; +#ifdef HAVE_LIBJACK + JackData *jdata; +#endif +/**X related info*/ + Display *dpy; //curtrent display +/** Mutexes*/ + pthread_mutex_t sound_buffer_mutex, + img_buff_ready_mutex, + theora_lib_mutex, //serializes access to th_encoding_clean w/theora_lib_clean + vorbis_lib_mutex, //serializes acces to v_encoding_clean w/vorbis_lib_clean + libogg_mutex, //libogg is not thread safe, + yuv_mutex; //this might not be needed since we only have + //one read-only and one write-only thread + //also on previous versions, + //y component was looped separately + //and then u and v so this was needed + //to avoid wrong coloring to render + //Currently this mutex only prevents + //the cursor from flickering +/**Condition Variables*/ + pthread_cond_t time_cond, //this gets a signal by the handler + //whenever it's time to get a screenshot + pause_cond, //this is blocks execution, + //when program is paused + sound_data_read, //a buffer is ready for proccessing + image_buffer_ready, //image encoding finished + theora_lib_clean, //the flush_ogg thread cannot + //procceed to creating last + vorbis_lib_clean; //packages until these two libs + //are no longer used, by other threads +/**Buffers,Flags and other vars*/ + unsigned char *dummy_pointer, //a dummy pointer to be drawn + //in every frame + //data is casted to unsigned for + //later use in YUV buffer + npxl; //this is the no pixel convention + //when drawing the dummy pointer + unsigned int periodtime,//time that a sound buffer lasts (microsecs) + frametime; //time that a frame lasts (microsecs) + Window shaped_w; //frame + int damage_event, //damage event base code + damage_error, //damage error base code + shm_opcode, //MIT-Shm opcode + dummy_p_size, //dummy pointer size,initially 16x16,always square + th_encoding_clean, //thread exit inidcator + v_encoding_clean, // >> >> + timer_alive, //determines loop of timer thread + hard_pause, //if sound device doesn't support pause + //we have to close and reopen + avd, //syncronization among audio and video + sound_framesize; //size of each sound frame + + /** Progam state vars */ + boolean running; //1 while the program is capturing/paused/encoding + boolean paused; //1 while the program is paused + boolean aborted; //1 if we should abort + boolean pause_state_changed; //1 if pause state changed + + //the following values are of no effect + //but they might be usefull later for profiling + unsigned int frames_total, //frames calculated by total time expirations + frames_lost; //the value of shame + + /* timer advances time_frameno, getframe copies time_frameno to capture_frameno + * access to both is serialized by time_{mutex,cond} + */ + unsigned int time_frameno, capture_frameno; + + pthread_mutex_t pause_mutex; + pthread_mutex_t time_mutex; + +#ifdef HAVE_LIBASOUND + snd_pcm_t *sound_handle; + snd_pcm_uframes_t periodsize; +#else + int sound_handle; + u_int32_t periodsize; +#endif +}; + + +//This is the header of every frame. +//Reconstruction will be correct only if made on +//the same platform. + +//We need the total number of blocks +//for each plane. + +//The number of the frame compared to the +//number of time expirations at the time of +//caching, will enable us to make up for lost frames. + + +typedef struct _FrameHeader{ + char frame_prefix[4]; //always FRAM + u_int32_t frameno, //number of frame(cached frames) + current_total; //number of frames that should have been + //taken at time of caching this one + u_int32_t Ynum, //number of changed blocks in the Y plane + Unum, //number of changed blocks in the U plane + Vnum; //number of changed blocks in the V plane +}FrameHeader; + +#endif + diff --git a/src/rmd_update_image.c b/src/rmd_update_image.c new file mode 100644 index 0000000..343e1bb --- /dev/null +++ b/src/rmd_update_image.c @@ -0,0 +1,95 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_update_image.h" + +#include "rmd_getzpixmap.h" +#include "rmd_yuv_utils.h" +#include "rmd_types.h" + +#include <X11/Xlibint.h> +#include <X11/extensions/shmproto.h> +#include <X11/extensions/XShm.h> + +#include <assert.h> + + +void rmdUpdateImage( Display * dpy, + yuv_buffer *yuv, + DisplaySpecs *specs, + RectArea **root, + BRWindow *brwin, + EncData *enc, + Image *image, + int noshmem, + int shm_opcode, + int no_quick_subsample){ + + RectArea *temp; + + for (temp = *root; temp; temp = temp->next) { + + /* sanity check the clipping, nothing on the reclist + * should go outside rrect + */ + assert(temp->rect.x >= brwin->rrect.x); + assert(temp->rect.y >= brwin->rrect.y); + assert(temp->rect.x + temp->rect.width <= brwin->rrect.x + brwin->rrect.width); + assert(temp->rect.y + temp->rect.height <= brwin->rrect.y + brwin->rrect.height); + + if (noshmem) { + rmdGetZPixmap( dpy, + specs->root, + image->ximage->data, + temp->rect.x, + temp->rect.y, + temp->rect.width, + temp->rect.height); + } else { + rmdGetZPixmapSHM( dpy, + specs->root, + &image->shm_info, + shm_opcode, + image->ximage->data, + temp->rect.x, + temp->rect.y, + temp->rect.width, + temp->rect.height); + } + rmdUpdateYuvBuffer( + yuv, + (unsigned char *)image->ximage->data, + NULL, + temp->rect.x - brwin->rrect.x, + temp->rect.y - brwin->rrect.y, + temp->rect.width, + temp->rect.height, + no_quick_subsample, + specs->depth + ); + } +} diff --git a/src/rmd_update_image.h b/src/rmd_update_image.h new file mode 100644 index 0000000..3057f18 --- /dev/null +++ b/src/rmd_update_image.h @@ -0,0 +1,70 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef UPDATE_IMAGE_H +#define UPDATE_IMAGE_H 1 + +#include "rmd_types.h" + +#include <X11/extensions/XShm.h> + +/** +* Retrieve and apply all changes, if xdamage is used. +* +* \param dpy Connection to the server +* +* \param yuv yuv_buffer that is to be modified +* +* \param specs DisplaySpecs struct with +* information about the display to be recorded +* +* \param root Root entry of the list with damaged areas +* +* \param brwin BRWindow struct contaning the recording window specs +* +* \param enc Encoding options +* +* \param datatemp Buffer for pixel data to be +* retrieved before placed on the yuv buffer +* +* \param noshmem don't use MIT_Shm extension +* +* \param no_quick_subsample Don't do quick subsampling +* +*/ +void rmdUpdateImage(Display * dpy, + yuv_buffer *yuv, + DisplaySpecs *specs, + RectArea **root, + BRWindow *brwin, + EncData *enc, + Image *image, + int noshmem, + int shm_opcode, + int no_quick_subsample); + + +#endif diff --git a/src/rmd_wm_check.c b/src/rmd_wm_check.c new file mode 100644 index 0000000..4934425 --- /dev/null +++ b/src/rmd_wm_check.c @@ -0,0 +1,76 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_wm_check.h" + +#include "rmd_types.h" + +#include <X11/Xatom.h> + + +char *rmdWMCheck(Display *dpy,Window root) { + Window *wm_child=NULL; + Atom nwm_atom, + utf8_string, + wm_name_atom, + rt; + unsigned long nbytes, nitems; + + char *wm_name_str=NULL; + int fmt; + + utf8_string = XInternAtom(dpy, "UTF8_STRING", False); + + nwm_atom =XInternAtom(dpy,"_NET_SUPPORTING_WM_CHECK",True); + wm_name_atom =XInternAtom(dpy,"_NET_WM_NAME",True); + + if (nwm_atom!=None && wm_name_atom!=None) { + + if (XGetWindowProperty( dpy,root,nwm_atom,0,100, + False,XA_WINDOW, + &rt,&fmt,&nitems, &nbytes, + (unsigned char **)((void*)&wm_child)) + != Success ) { + fprintf(stderr,"Error while trying to get a" + " window to identify the window manager.\n"); + } + + if ((wm_child == NULL)|| + (XGetWindowProperty(dpy,*wm_child,wm_name_atom,0,100, + False,utf8_string,&rt, + &fmt,&nitems, &nbytes, + (unsigned char **)((void*)&wm_name_str)) + !=Success)) { + fprintf(stderr,"Warning!!!\nYour window manager appears" + " to be non-compliant!\n"); + } + } + fprintf(stderr, "Your window manager appears to be %s\n\n", + ((wm_name_str!=NULL)?wm_name_str:"Unknown")); + + return wm_name_str; +} diff --git a/src/rmd_wm_check.h b/src/rmd_wm_check.h new file mode 100644 index 0000000..12f33dd --- /dev/null +++ b/src/rmd_wm_check.h @@ -0,0 +1,45 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef WM_CHECK_H +#define WM_CHECK_H 1 + +#include "rmd_types.h" + + +/** +*Check current running window manager. +* +* \param dpy Connection to the server +* +* \param root root window of the display +* +* \returns Window manager name +*/ +char *rmdWMCheck(Display *dpy,Window root); + + +#endif diff --git a/src/rmd_wm_is_compositing.c b/src/rmd_wm_is_compositing.c new file mode 100644 index 0000000..bc43282 --- /dev/null +++ b/src/rmd_wm_is_compositing.c @@ -0,0 +1,61 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_wm_is_compositing.h" + +#include "rmd_wm_check.h" +#include "rmd_types.h" + +#include <X11/Xatom.h> + +#include <stdlib.h> + + +boolean rmdWMIsCompositing( Display *dpy, int screen ) { + Window win; + Atom atom; + char buf[32]; + char *window_manager=rmdWMCheck( dpy, RootWindow( dpy, screen ) ); + + //If the wm name is queried successfully the wm is compliant (source + //http://standards.freedesktop.org/wm-spec/1.4/ar01s03.html#id2568282 ) + //in which case we will also free() the allcoated string. + + if (window_manager == NULL) + return FALSE; + else + free(window_manager); + + snprintf( buf, sizeof(buf), "_NET_WM_CM_S%d", screen); + atom = XInternAtom(dpy, buf, True); + if (atom == None) + return FALSE; + + win = XGetSelectionOwner(dpy, atom); + + return win != None; +} diff --git a/src/rmd_wm_is_compositing.h b/src/rmd_wm_is_compositing.h new file mode 100644 index 0000000..7f152ac --- /dev/null +++ b/src/rmd_wm_is_compositing.h @@ -0,0 +1,48 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef RMD_WM_IS_COMPOSITING_H +#define RMD_WM_IS_COMPOSITING_H 1 + +#include "rmd_types.h" + + +/** +*Check if the window manager is compositing (duh!). +* +* \param dpy Connection to the server +* +* \param screen screen number/id that the window manager runs on +* +* \returns TRUE if compositing, false otherwise or when +* the window manager doesn't support the required +* freedesktop.org hints for the test to be done +* succesfully. +*/ + +boolean rmdWMIsCompositing( Display *dpy, int screen) ; + +#endif diff --git a/src/rmd_yuv_utils.c b/src/rmd_yuv_utils.c new file mode 100644 index 0000000..1f163ae --- /dev/null +++ b/src/rmd_yuv_utils.c @@ -0,0 +1,517 @@ +/****************************************************************************** +* recordMyDesktop - rmd_yuv_utils.c * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* Copyright (C) 2008 Luca Bonavita * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#include "config.h" +#include "rmd_yuv_utils.h" + +#include "rmd_math.h" + + +// Keep these global (for performance reasons I assume). +unsigned char Yr[256], Yg[256], Yb[256], + Ur[256], Ug[256], UbVr[256], + Vg[256], Vb[256]; + +// FIXME: These globals are modified in other source files! We keep +// thsee here for now. These are the cache blocks. They need to be +// accesible in the dbuf macros +unsigned char *yblocks, + *ublocks, + *vblocks; + +void rmdMakeMatrices (void) { + int i; + + /* assuming 8-bit precision */ + float Yscale = 219.0, Yoffset = 16.0; + float Cscale = 224.0, Coffset = 128.0; + float RGBscale = 255.0; + + float r, g, b; + float yr, yg, yb; + float ur, ug, ub; + float vg, vb; /* vr intentionally missing */ + + /* as for ITU-R BT-601-6 specifications: */ + r = 0.299; + b = 0.114; + g = 1.0 - r - b; + + /* as a note, here are the coefficients + as for ITU-R BT-709 specifications: + r=0.2126; b=0.0722; g=1.0-r-b; */ + + yr = r * Yscale / RGBscale; + yg = g * Yscale / RGBscale; + yb = b * Yscale / RGBscale; + ur = ( -0.5 * r / ( 1 - b ) ) * Cscale / RGBscale; + ug = ( -0.5 * g / ( 1 - b ) ) * Cscale / RGBscale; + ub = ( 0.5 * Cscale / RGBscale); + /* vr = ub so UbVr = ub*i = vr*i */ + vg = ( -0.5 * g / ( 1 - r ) ) * Cscale / RGBscale; + vb = ( -0.5 * b / ( 1 - r ) ) * Cscale / RGBscale; + + for (i = 0; i < 256; i++) { + Yr[i] = (unsigned char) rmdRoundf( Yoffset + yr * i ); + Yg[i] = (unsigned char) rmdRoundf( yg * i ); + Yb[i] = (unsigned char) rmdRoundf( yb * i ); + + Ur[i] = (unsigned char) rmdRoundf( Coffset + ur * i ); + Ug[i] = (unsigned char) rmdRoundf( ug * i ); + UbVr[i] = (unsigned char) rmdRoundf( ub * i ); + + Vg[i] = (unsigned char) rmdRoundf( vg * i ); + Vb[i] = (unsigned char) rmdRoundf( Coffset + vb * i ); + } +} + +static inline int blocknum(int xv, int yv, int widthv, int blocksize) +{ + return ((yv/blocksize) * (widthv/blocksize) + (xv/blocksize)); +} + +/* These at least make some sense as macros since they need duplication for + * the multiple depths, so I've just moved and reformatted them here for now. + */ + +#define UPDATE_Y_PLANE( data, \ + x_tm, \ + y_tm, \ + width_tm, \ + height_tm, \ + yuv, \ + __depth__) { \ + \ + register unsigned char *yuv_Y = (yuv)->y + x_tm + y_tm * (yuv)->y_stride, \ + *_yr = Yr, *_yg = Yg, *_yb = Yb; \ + register u_int##__depth__##_t *datapi = (u_int##__depth__##_t *)data; \ + \ + for (int k = 0; k < height_tm; k++) { \ + for (int i = 0; i < width_tm; i++) { \ + register u_int##__depth__##_t t_val = *datapi; \ + \ + *yuv_Y = _yr[__RVALUE_##__depth__(t_val)] + \ + _yg[__GVALUE_##__depth__(t_val)] + \ + _yb[__BVALUE_##__depth__(t_val)]; \ + datapi++; \ + yuv_Y++; \ + } \ + \ + yuv_Y += (yuv)->y_stride - width_tm; \ + } \ +} + +//when adding the r values, we go beyond +//the (16 bit)range of the t_val variable, but we are performing +//32 bit arithmetics, so there's no problem. +//(This note is useless, I'm just adding because +//the addition of the A components in CALC_TVAL_AVG_32, +//now removed as uneeded, produced an overflow which would have caused +//color distrtion, where it one of the R,G or B components) +#define CALC_TVAL_AVG_16(t_val, datapi, datapi_next) { \ + register u_int16_t t1, t2, t3, t4; \ + \ + t1 = *datapi; \ + t2 = *(datapi + 1); \ + t3 = *datapi_next; \ + t4 = *(datapi_next + 1); \ + \ + t_val = ((((t1 & __R16_MASK) + (t2 & __R16_MASK) + \ + (t3 & __R16_MASK) + (t4 & __R16_MASK)) / 4) & __R16_MASK) + \ + ((((t1 & __G16_MASK) + (t2 & __G16_MASK)+ \ + (t3 & __G16_MASK) + (t4 & __G16_MASK)) / 4) & __G16_MASK) + \ + ((((t1 & __B16_MASK) + (t2 & __B16_MASK) + \ + (t3 & __B16_MASK) + (t4 & __B16_MASK)) / 4) & __B16_MASK); \ +} + +//the 4 most significant bytes represent the A component which +//does not need to be added on t_val, as it is always unused +#define CALC_TVAL_AVG_32(t_val, datapi, datapi_next) { \ + register unsigned int t1, t2, t3, t4; \ + \ + t1 = *datapi; \ + t2 = *(datapi + 1); \ + t3 = *datapi_next; \ + t4 = *(datapi_next + 1); \ + \ + t_val = ((((t1 & 0x00ff0000) + (t2 & 0x00ff0000) + \ + (t3 & 0x00ff0000) + (t4 & 0x00ff0000)) / 4) & 0x00ff0000) + \ + ((((t1 & 0x0000ff00) + (t2 & 0x0000ff00) + \ + (t3 & 0x0000ff00) + (t4 & 0x0000ff00)) / 4) & 0x0000ff00) + \ + ((((t1 & 0x000000ff) + (t2 & 0x000000ff) + \ + (t3 & 0x000000ff) + (t4 & 0x000000ff)) / 4) & 0x000000ff); \ +} + +#define UPDATE_A_UV_PIXEL( yuv_U, \ + yuv_V, \ + t_val, \ + datapi, \ + datapi_next, \ + _ur,_ug,_ubvr,_vg,_vb, \ + sampling, \ + __depth__) \ + \ + if (sampling == __PXL_AVERAGE) { \ + CALC_TVAL_AVG_##__depth__(t_val, datapi, datapi_next) \ + } else \ + t_val = *(datapi); \ + \ + *(yuv_U) = _ur[__RVALUE_##__depth__(t_val)] + \ + _ug[__GVALUE_##__depth__(t_val)] + \ + _ubvr[__BVALUE_##__depth__(t_val)]; \ + \ + *(yuv_V) = _ubvr[__RVALUE_##__depth__(t_val)] + \ + _vg[__GVALUE_##__depth__(t_val)] + \ + _vb[__BVALUE_##__depth__(t_val)]; + +#define UPDATE_UV_PLANES( data, \ + x_tm, \ + y_tm, \ + width_tm, \ + height_tm, \ + yuv, \ + sampling, \ + __depth__) { \ + \ + register u_int##__depth__##_t t_val; \ + register unsigned char *yuv_U = (yuv)->u + x_tm / 2 + \ + (y_tm * (yuv)->uv_width) / 2, \ + *yuv_V = (yuv)->v + x_tm / 2 + \ + (y_tm * (yuv)->uv_width) / 2, \ + *_ur = Ur, *_ug = Ug, *_ubvr = UbVr, \ + *_vg = Vg, *_vb = Vb; \ + register u_int##__depth__##_t *datapi = (u_int##__depth__##_t *)data, \ + *datapi_next = NULL; \ + int w_odd = width_tm % 2, h_odd = height_tm % 2; \ + \ + if (sampling == __PXL_AVERAGE) \ + datapi_next = datapi + width_tm; \ + \ + for (int k = 0; k < height_tm - h_odd; k += 2) { \ + for (int i = 0; i < width_tm - w_odd; i += 2) { \ + UPDATE_A_UV_PIXEL( yuv_U, \ + yuv_V, \ + t_val, \ + datapi, \ + datapi_next, \ + _ur, _ug, _ubvr, _vg, _vb, \ + sampling, \ + __depth__); \ + \ + datapi += 2; \ + if (sampling == __PXL_AVERAGE) \ + datapi_next += 2; \ + yuv_U++; \ + yuv_V++; \ + } \ + \ + yuv_U += ((yuv)->y_stride - (width_tm - w_odd * 2)) >> 1; \ + yuv_V += ((yuv)->y_stride - (width_tm - w_odd * 2)) >> 1; \ + \ + datapi += width_tm + w_odd; \ + if (sampling == __PXL_AVERAGE) \ + datapi_next += width_tm + w_odd; \ + } \ +} + +#define UPDATE_Y_PLANE_DBUF( data, \ + data_back, \ + x_tm, \ + y_tm, \ + width_tm, \ + height_tm, \ + yuv, \ + __depth__) { \ + \ + register u_int##__depth__##_t t_val; \ + register unsigned char *yuv_Y = (yuv)->y + x_tm + y_tm * (yuv)->y_stride, \ + *_yr = Yr, *_yg = Yg, *_yb = Yb; \ + register u_int##__depth__##_t *datapi = (u_int##__depth__##_t *)data, \ + *datapi_back = (u_int##__depth__##_t *)data_back; \ + \ + for (int k = 0; k < height_tm; k++) { \ + for (int i = 0; i < width_tm; i++) { \ + if (*datapi != *datapi_back) { \ + t_val = *datapi; \ + *yuv_Y = _yr[__RVALUE_##__depth__(t_val)] + \ + _yg[__GVALUE_##__depth__(t_val)] + \ + _yb[__BVALUE_##__depth__(t_val)]; \ + yblocks[blocknum(x_tm + i, y_tm + k, (yuv)->y_width, Y_UNIT_WIDTH)] = 1;\ + } \ + datapi++; \ + datapi_back++; \ + yuv_Y++; \ + } \ + yuv_Y += (yuv)->y_stride - width_tm; \ + } \ +} + +#define UPDATE_UV_PLANES_DBUF( data, \ + data_back, \ + x_tm, \ + y_tm, \ + width_tm, \ + height_tm, \ + yuv, \ + sampling, \ + __depth__) { \ + \ + register u_int##__depth__##_t t_val; \ + register unsigned char *yuv_U = (yuv)->u + x_tm / 2 + \ + (y_tm * (yuv)->uv_width) / 2, \ + *yuv_V = (yuv)->v + x_tm / 2 + \ + (y_tm * (yuv)->uv_width) / 2, \ + *_ur = Ur, *_ug = Ug, *_ubvr = UbVr, \ + *_vg = Vg, *_vb = Vb; \ + \ + register u_int##__depth__##_t *datapi = (u_int##__depth__##_t *)data, \ + *datapi_next = NULL, \ + *datapi_back = (u_int##__depth__##_t *)data_back, \ + *datapi_back_next = NULL; \ + int w_odd = width_tm % 2, h_odd = height_tm % 2; \ + \ + if (sampling == __PXL_AVERAGE) { \ + datapi_next = datapi + width_tm; \ + datapi_back_next = datapi_back + width_tm; \ + \ + for (int k = 0; k < height_tm - h_odd; k += 2) { \ + for (int i = 0; i < width_tm - w_odd; i += 2) { \ + if ( (*datapi != *datapi_back || \ + (*(datapi + 1) != *(datapi_back + 1)) || \ + (*datapi_next != *datapi_back_next) || \ + (*(datapi_next + 1) != *(datapi_back_next + 1)))) { \ + \ + UPDATE_A_UV_PIXEL( yuv_U, \ + yuv_V, \ + t_val, \ + datapi, \ + datapi_next, \ + _ur,_ug,_ubvr,_vg,_vb, \ + sampling, \ + __depth__); \ + \ + ublocks[blocknum(x_tm + i, y_tm + k, (yuv)->y_width, Y_UNIT_WIDTH)] = 1; \ + vblocks[blocknum(x_tm + i, y_tm + k, (yuv)->y_width, Y_UNIT_WIDTH)] = 1; \ + } \ + \ + datapi += 2; \ + datapi_back += 2; \ + datapi_next += 2; \ + datapi_back_next += 2; \ + \ + yuv_U++; \ + yuv_V++; \ + } \ + \ + yuv_U += ((yuv)->y_stride - (width_tm - w_odd * 2)) >> 1; \ + yuv_V += ((yuv)->y_stride - (width_tm - w_odd * 2)) >> 1; \ + \ + datapi += width_tm + w_odd; \ + datapi_back += width_tm + w_odd; \ + datapi_next += width_tm + w_odd; \ + datapi_back_next += width_tm + w_odd; \ + } \ + } else { \ + for (int k = 0; k < height_tm - h_odd; k += 2) { \ + for (int i = 0; i < width_tm - w_odd; i += 2) { \ + if ((*datapi != *datapi_back)) { \ + UPDATE_A_UV_PIXEL( yuv_U, \ + yuv_V, \ + t_val, \ + datapi, \ + datapi_next, \ + _ur, _ug, _ubvr, _vg, _vb, \ + sampling, \ + __depth__); \ + \ + ublocks[blocknum(x_tm + i, y_tm + k, (yuv)->y_width, Y_UNIT_WIDTH)] = 1; \ + vblocks[blocknum(x_tm + i, y_tm + k, (yuv)->y_width, Y_UNIT_WIDTH)] = 1; \ + } \ + \ + datapi += 2; \ + datapi_back += 2; \ + \ + yuv_U++; \ + yuv_V++; \ + } \ + \ + yuv_U += ((yuv)->y_stride - (width_tm - w_odd * 2)) >> 1; \ + yuv_V += ((yuv)->y_stride - (width_tm - w_odd * 2)) >> 1; \ + \ + datapi += width_tm + w_odd; \ + datapi_back += width_tm + w_odd; \ + } \ + } \ +} + +void rmdUpdateYuvBuffer( yuv_buffer *yuv, + unsigned char *data, + unsigned char *data_back, + int x_tm, + int y_tm, + int width_tm, + int height_tm, + int sampling, + int depth) { + + if (data_back == NULL) { + switch (depth) { + case 24: + case 32: + UPDATE_Y_PLANE(data, x_tm, y_tm, width_tm, height_tm, yuv, 32); + UPDATE_UV_PLANES(data, x_tm, y_tm, width_tm, height_tm, yuv, sampling, 32); + break; + case 16: + UPDATE_Y_PLANE(data, x_tm, y_tm, width_tm, height_tm, yuv, 16); + UPDATE_UV_PLANES(data, x_tm, y_tm, width_tm, height_tm, yuv, sampling, 16); + break; + default: + assert(0); + } + } else { + switch (depth) { + case 24: + case 32: + UPDATE_Y_PLANE_DBUF(data, data_back, x_tm, y_tm, width_tm, height_tm, yuv, 32); + UPDATE_UV_PLANES_DBUF(data, data_back, x_tm, y_tm, width_tm, height_tm, yuv, sampling, 32); + break; + case 16: + UPDATE_Y_PLANE_DBUF(data, data_back, x_tm, y_tm, width_tm, height_tm, yuv, 16); + UPDATE_UV_PLANES_DBUF(data, data_back, x_tm, y_tm, width_tm, height_tm, yuv, sampling, 16); + break; + default: + assert(0); + } + } +} + +void rmdDummyPointerToYuv( yuv_buffer *yuv, + unsigned char *data_tm, + int x_tm, + int y_tm, + int width_tm, + int height_tm, + int x_offset, + int y_offset, + unsigned char no_pixel) { + + int i, k, j = 0; + int x_2 = x_tm / 2, y_2 = y_tm / 2, y_width_2 = yuv->y_width/2; + + for (k = y_offset; k < y_offset + height_tm; k++) { + for (i = x_offset; i < x_offset + width_tm; i++) { + j = k * 16 + i; + + if (data_tm[j * 4] != no_pixel) { + yuv->y[x_tm + (i - x_offset) + ((k - y_offset) + y_tm) * yuv->y_width] = + Yr[data_tm[j * 4 + __RBYTE]] + + Yg[data_tm[j * 4 + __GBYTE]] + + Yb[data_tm[j * 4 + __BBYTE]]; + + if ((k % 2) && (i % 2)) { + yuv->u[x_2 + (i - x_offset) / 2 + ((k - y_offset) / 2 + y_2) * y_width_2] = + Ur[data_tm[(k * width_tm + i) * 4 + __RBYTE]] + + Ug[data_tm[(k * width_tm + i) * 4 + __GBYTE]] + + UbVr[data_tm[(k * width_tm + i) * 4 + __BBYTE]]; + yuv->v[x_2 + (i - x_offset) / 2 + ((k - y_offset) / 2 + y_2) * y_width_2] = + UbVr[data_tm[(k * width_tm + i) * 4 + __RBYTE]] + + Vg[data_tm[(k * width_tm + i) * 4 + __GBYTE]] + + Vb[data_tm[(k * width_tm + i) * 4 + __BBYTE]] ; + } + } + } + } + +} + +static inline unsigned char avg_4_pixels( unsigned char *data_array, + int width_img, + int k_tm, + int i_tm, + int offset) +{ + + return ((data_array[(k_tm*width_img+i_tm)*RMD_ULONG_SIZE_T+offset]+ + data_array[((k_tm-1)*width_img+i_tm)*RMD_ULONG_SIZE_T+offset]+ + data_array[(k_tm*width_img+i_tm-1)*RMD_ULONG_SIZE_T+offset]+ + data_array[((k_tm-1)*width_img+i_tm-1)*RMD_ULONG_SIZE_T+offset])/4); +} + +void rmdXFixesPointerToYuv( yuv_buffer *yuv, + unsigned char *data_tm, + int x_tm, + int y_tm, + int width_tm, + int height_tm, + int x_offset, + int y_offset, + int column_discard_stride) { + + unsigned char avg0, avg1, avg2, avg3; + int x_2 = x_tm / 2, y_2 = y_tm / 2; + + for (int k = y_offset; k < y_offset + height_tm; k++) { + for (int i = x_offset;i < x_offset + width_tm; i++) { + int j = k * (width_tm + column_discard_stride) + i; + + yuv->y[x_tm + (i - x_offset) + (k + y_tm - y_offset) * yuv->y_width] = + (yuv->y[x_tm + (i - x_offset) + (k - y_offset + y_tm) * yuv->y_width] * + (UCHAR_MAX - data_tm[(j * RMD_ULONG_SIZE_T) + __ABYTE]) + + ( ( Yr[data_tm[(j * RMD_ULONG_SIZE_T) + __RBYTE]] + + Yg[data_tm[(j * RMD_ULONG_SIZE_T) + __GBYTE]] + + Yb[data_tm[(j * RMD_ULONG_SIZE_T) + __BBYTE]] ) % + ( UCHAR_MAX + 1 ) ) * + data_tm[(j * RMD_ULONG_SIZE_T) + __ABYTE]) / UCHAR_MAX; + + if ((k % 2) && (i % 2)) { + int idx = x_2 + (i - x_offset) / 2 + ((k - y_offset) / 2 + y_2) * yuv->uv_width; + + avg3 = avg_4_pixels( data_tm, + (width_tm + column_discard_stride), + k, i, __ABYTE); + avg2 = avg_4_pixels( data_tm, + (width_tm + column_discard_stride), + k, i, __RBYTE); + avg1 = avg_4_pixels( data_tm, + (width_tm + column_discard_stride), + k, i, __GBYTE); + avg0 = avg_4_pixels( data_tm, + (width_tm + column_discard_stride), + k, i, __BBYTE); + + yuv->u[idx] = + (yuv->u[idx] * (UCHAR_MAX - avg3) + + ((Ur[avg2] + Ug[avg1] + UbVr[avg0]) % (UCHAR_MAX + 1)) + * avg3) / UCHAR_MAX; + + yuv->v[idx]= + (yuv->u[idx] * (UCHAR_MAX - avg3) + + ((UbVr[avg2] + Vg[avg1] + Vb[avg0]) % (UCHAR_MAX + 1)) + * avg3) / UCHAR_MAX; + } + } + } +} diff --git a/src/rmd_yuv_utils.h b/src/rmd_yuv_utils.h new file mode 100644 index 0000000..f92471a --- /dev/null +++ b/src/rmd_yuv_utils.h @@ -0,0 +1,83 @@ +/****************************************************************************** +* recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2006,2007,2008 John Varouhakis * +* * +* * +* 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 * +* * +* * +* * +* For further information contact me at johnvarouhakis@gmail.com * +******************************************************************************/ + +#ifndef YUV_UTILS_H +#define YUV_UTILS_H 1 + +#include "rmd_macro.h" +#include "rmd_types.h" + + +// The macros work directly on this data (for performance reasons I +// suppose) so we keep this global +extern unsigned char Yr[256], Yg[256], Yb[256], + Ur[256], Ug[256], UbVr[256], + Vg[256], Vb[256]; + + +// We keep these global for now. FIXME: Isolate them. +extern unsigned char *yblocks, + *ublocks, + *vblocks; + + +/** +* Fill Yr,Yg,Yb,Ur,Ug.Ub,Vr,Vg,Vb arrays(globals) with values. +*/ +void rmdMakeMatrices(void); + +/* update yuv from data and optionally data_back */ +void rmdUpdateYuvBuffer( yuv_buffer *yuv, + unsigned char *data, + unsigned char *data_back, + int x_tm, + int y_tm, + int width_tm, + int height_tm, + int sampling_type, + int color_depth); + +void rmdDummyPointerToYuv( yuv_buffer *yuv, + unsigned char *data_tm, + int x_tm, + int y_tm, + int width_tm, + int height_tm, + int x_offset, + int y_offset, + unsigned char no_pixel); + +void rmdXFixesPointerToYuv( yuv_buffer *yuv, + unsigned char *data_tm, + int x_tm, + int y_tm, + int width_tm, + int height_tm, + int x_offset, + int y_offset, + int column_discard_stride); + +#endif diff --git a/src/skeleton.c b/src/skeleton.c new file mode 100644 index 0000000..77567db --- /dev/null +++ b/src/skeleton.c @@ -0,0 +1,296 @@ +/* + * skeleton.c + * author: Tahseen Mohammad + */ + +/* This file depends on WORDS_BIGENDIAN being defined to 1 if the host + * processor stores words with the most significant byte first (like Motorola + * and SPARC, unlike Intel and VAX). + * On little endian systems, WORDS_BIGENDIAN should be undefined. + * + * When using GNU Autotools, the correct value will be written into config.h + * if the autoconf macro AC_C_BIGENDIAN is called in configure.ac. + */ +#include "config.h" + +#include <stdlib.h> +#include <string.h> +#include <stdio.h> + +#include <ogg/ogg.h> + +#include "skeleton.h" + +#ifdef WIN32 +#define snprintf _snprintf +#endif + +static unsigned short +_le_16 (unsigned short s) +{ + unsigned short ret=s; +#ifdef WORDS_BIGENDIAN + ret = (s>>8) & 0x00ffU; + ret += (s<<8) & 0xff00U; +#endif + return ret; +} + +static ogg_uint32_t +_le_32 (ogg_uint32_t i) +{ + ogg_uint32_t ret=i; +#ifdef WORDS_BIGENDIAN + ret = (i>>24); + ret += (i>>8) & 0x0000ff00; + ret += (i<<8) & 0x00ff0000; + ret += (i<<24); +#endif + return ret; +} + +static ogg_int64_t +_le_64 (ogg_int64_t l) +{ + ogg_int64_t ret=l; + unsigned char *ucptr = (unsigned char *)&ret; +#ifdef WORDS_BIGENDIAN + unsigned char temp; + + temp = ucptr [0] ; + ucptr [0] = ucptr [7] ; + ucptr [7] = temp ; + + temp = ucptr [1] ; + ucptr [1] = ucptr [6] ; + ucptr [6] = temp ; + + temp = ucptr [2] ; + ucptr [2] = ucptr [5] ; + ucptr [5] = temp ; + + temp = ucptr [3] ; + ucptr [3] = ucptr [4] ; + ucptr [4] = temp ; + +#endif + return (*(ogg_int64_t *)ucptr); +} + +/* write an ogg_page to a file pointer */ +int write_ogg_page_to_file(ogg_page *og, FILE *out) { + int written; + + written = fwrite(og->header,1, og->header_len, out); + if (written > 0) + written += fwrite(og->body,1, og->body_len, out); + + return written; +} + +int add_message_header_field(fisbone_packet *fp, + char *header_key, + char *header_value) { + + /* size of both key and value + ': ' + CRLF */ + int this_message_size = strlen(header_key) + strlen(header_value) + 4; + if (fp->message_header_fields == NULL) { + fp->message_header_fields = _ogg_calloc(this_message_size+1, sizeof(char)); + } else { + int new_size = (fp->current_header_size + this_message_size+1) * sizeof(char); + fp->message_header_fields = _ogg_realloc(fp->message_header_fields, new_size); + } + snprintf(fp->message_header_fields + fp->current_header_size, + this_message_size+1, + "%s: %s\r\n", + header_key, + header_value); + fp->current_header_size += this_message_size; + + return 0; +} + +/* create a ogg_packet from a fishead_packet structure */ +int ogg_from_fishead(fishead_packet *fp,ogg_packet *op) { + + if (!fp || !op) return -1; + + memset(op, 0, sizeof(*op)); + op->packet = _ogg_calloc(FISHEAD_SIZE, sizeof(unsigned char)); + if (!op->packet) return -1; + + memset(op->packet, 0, FISHEAD_SIZE); + + memcpy (op->packet, FISHEAD_IDENTIFIER, 8); /* identifier */ + *((ogg_uint16_t*)(op->packet+8)) = _le_16 (SKELETON_VERSION_MAJOR); /* version major */ + *((ogg_uint16_t*)(op->packet+10)) = _le_16 (SKELETON_VERSION_MINOR); /* version minor */ + *((ogg_int64_t*)(op->packet+12)) = _le_64 (fp->ptime_n); /* presentationtime numerator */ + *((ogg_int64_t*)(op->packet+20)) = _le_64 (fp->ptime_d); /* presentationtime denominator */ + *((ogg_int64_t*)(op->packet+28)) = _le_64 (fp->btime_n); /* basetime numerator */ + *((ogg_int64_t*)(op->packet+36)) = _le_64 (fp->btime_d); /* basetime denominator */ + /* TODO: UTC time, set to zero for now */ + + op->b_o_s = 1; /* its the first packet of the stream */ + op->e_o_s = 0; /* its not the last packet of the stream */ + op->bytes = FISHEAD_SIZE; /* length of the packet in bytes */ + + return 0; +} + +/* create a ogg_packet from a fisbone_packet structure. + * call this method after the fisbone_packet is filled and all message header fields are added + * by calling add_message_header_field method. + */ +int ogg_from_fisbone(fisbone_packet *fp,ogg_packet *op) { + + int packet_size; + + if (!fp || !op) return -1; + + packet_size = FISBONE_SIZE + fp->current_header_size; + + memset (op, 0, sizeof (*op)); + op->packet = _ogg_calloc (packet_size, sizeof(unsigned char)); + if (!op->packet) return -1; + + memset (op->packet, 0, packet_size); + memcpy (op->packet, FISBONE_IDENTIFIER, 8); /* identifier */ + *((ogg_uint32_t*)(op->packet+8)) = _le_32 (FISBONE_MESSAGE_HEADER_OFFSET); /* offset of the message header fields */ + *((ogg_uint32_t*)(op->packet+12)) = _le_32 (fp->serial_no); /* serialno of the respective stream */ + *((ogg_uint32_t*)(op->packet+16)) = _le_32 (fp->nr_header_packet); /* number of header packets */ + *((ogg_int64_t*)(op->packet+20)) = _le_64 (fp->granule_rate_n); /* granulrate numerator */ + *((ogg_int64_t*)(op->packet+28)) = _le_64 (fp->granule_rate_d); /* granulrate denominator */ + *((ogg_int64_t*)(op->packet+36)) = _le_64 (fp->start_granule); /* start granule */ + *((ogg_uint32_t*)(op->packet+44)) = _le_32 (fp->preroll); /* preroll, for theora its 0 */ + *(op->packet+48) = fp->granule_shift; /* granule shift */ + if (fp->message_header_fields) + memcpy((op->packet+FISBONE_SIZE), fp->message_header_fields, fp->current_header_size); + + + op->b_o_s = 0; + op->e_o_s = 0; + op->bytes = packet_size; /* size of the packet in bytes */ + + return 0; +} + +/* fills up a fishead_packet from memory */ +static int fishead_from_data (const unsigned char * data, int len, fishead_packet *fp) { + if (!data) return -1; + + if (memcmp(data, FISHEAD_IDENTIFIER, 8)) + return -1; + + fp->version_major = _le_16 (*((ogg_uint16_t*)(data+8))); /* version major */ + fp->version_minor = _le_16 (*((ogg_uint16_t*)(data+10))); /* version minor */ + fp->ptime_n = _le_64 (*((ogg_int64_t*)(data+12))); /* presentationtime numerator */ + fp->ptime_d = _le_64 (*((ogg_int64_t*)(data+20))); /* presentationtime denominator */ + fp->btime_n = _le_64 (*((ogg_int64_t*)(data+28))); /* basetime numerator */ + fp->btime_d = _le_64 (*((ogg_int64_t*)(data+36))); /* basetime denominator */ + memcpy(fp->UTC, data+44, 20); + + return 0; +} + +/* fills up a fishead_packet from a fishead ogg_packet of a skeleton bistream */ +int fishead_from_ogg (ogg_packet *op, fishead_packet *fp) { + return fishead_from_data (op->packet, op->bytes, fp); +} + +/* fills up a fishead_packet from a fishead ogg_page of a skeleton bistream */ +int fishead_from_ogg_page (const ogg_page *og, fishead_packet *fp) { + return fishead_from_data (og->body, og->body_len, fp); +} + +/* fills up a fisbone_packet from memory */ +static int fisbone_from_data (const unsigned char * data, int len, fisbone_packet *fp) { + + if (!fp) return -1; + + if (memcmp(data, FISBONE_IDENTIFIER, 8)) + return -1; + + fp->serial_no = _le_32 (*((ogg_uint32_t*)(data+12))); /* serialno of the stream represented by this fisbone packet */ + fp->nr_header_packet = _le_32 (*((ogg_uint32_t*)(data+16))); /* number of header packets */ + fp->granule_rate_n = _le_64 (*((ogg_int64_t*)(data+20))); /* granulrate numerator */ + fp->granule_rate_d = _le_64 (*((ogg_int64_t*)(data+28))); /* granulrate denominator */ + fp->start_granule = _le_64 (*((ogg_int64_t*)(data+36))); /* start granule */ + fp->preroll = _le_32 (*((ogg_uint32_t*)(data+44))); /* preroll, for theora its 0 */ + fp->granule_shift = *(data+48); /* granule shift */ + fp->current_header_size = len - FISBONE_SIZE; + fp->message_header_fields = _ogg_calloc(fp->current_header_size+1, sizeof(char)); + if (!fp->message_header_fields) return -1; + memcpy(fp->message_header_fields, data+FISBONE_SIZE, fp->current_header_size); + + return 0; +} + +/* fills up a fisbone_packet from a fisbone ogg_packet of a skeleton bitstream */ +int fisbone_from_ogg (ogg_packet *op, fisbone_packet *fp) { + return fisbone_from_data (op->packet, op->bytes, fp); +} + +/* fills up a fisbone_packet from a fisbone ogg_page of a skeleton bistream */ +int fisbone_from_ogg_page (const ogg_page *og, fisbone_packet *fp) { + return fisbone_from_data (og->body, og->body_len, fp); +} + +int fisbone_clear(fisbone_packet *fp) +{ + if (!fp) return -1; + _ogg_free(fp->message_header_fields); + return 0; +} + +int add_fishead_to_stream(ogg_stream_state *os, fishead_packet *fp) { + + ogg_packet op; + int ret; + + ret = ogg_from_fishead(fp, &op); + if (ret<0) return ret; + ogg_stream_packetin(os, &op); + _ogg_free(op.packet); + + return 0; +} + +int add_fisbone_to_stream(ogg_stream_state *os, fisbone_packet *fp) { + + ogg_packet op; + int ret; + + ret = ogg_from_fisbone(fp, &op); + if (ret<0) return ret; + ogg_stream_packetin(os, &op); + _ogg_free(op.packet); + + return 0; +} + +int add_eos_packet_to_stream(ogg_stream_state *os) { + + ogg_packet op; + + memset (&op, 0, sizeof(op)); + op.e_o_s = 1; + ogg_stream_packetin(os, &op); + + return 0; +} + +int flush_ogg_stream_to_file(ogg_stream_state *os, FILE *out) { + + ogg_page og; + int result; + + while((result = ogg_stream_flush(os, &og))) + { + if(!result) break; + result = write_ogg_page_to_file(&og, out); + if(result != og.header_len + og.body_len) + return 1; + } + + return 0; +} diff --git a/src/skeleton.h b/src/skeleton.h new file mode 100644 index 0000000..d088e3e --- /dev/null +++ b/src/skeleton.h @@ -0,0 +1,78 @@ +/* + * skeleton.h + * author: Tahseen Mohammad + */ + +#ifndef _SKELETON_H +#define _SKELETON_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdio.h> +#include <ogg/ogg.h> + +#define SKELETON_VERSION_MAJOR 3 +#define SKELETON_VERSION_MINOR 0 +#define FISHEAD_IDENTIFIER "fishead\0" +#define FISBONE_IDENTIFIER "fisbone\0" +#define FISHEAD_SIZE 64 +#define FISBONE_SIZE 52 +#define FISBONE_MESSAGE_HEADER_OFFSET 44 + +/* fishead_packet holds a fishead header packet. */ +typedef struct { + ogg_uint16_t version_major; /* skeleton version major */ + ogg_uint16_t version_minor; /* skeleton version minor */ + /* Start time of the presentation + * For a new stream presentationtime & basetime is same. */ + ogg_int64_t ptime_n; /* presentation time numerator */ + ogg_int64_t ptime_d; /* presentation time denominator */ + ogg_int64_t btime_n; /* basetime numerator */ + ogg_int64_t btime_d; /* basetime denominator */ + /* will holds the time of origin of the stream, a 20 bit field. */ + unsigned char UTC[20]; +} fishead_packet; + +/* fisbone_packet holds a fisbone header packet. */ +typedef struct { + ogg_uint32_t serial_no; /* serial no of the corresponding stream */ + ogg_uint32_t nr_header_packet; /* number of header packets */ + /* granule rate is the temporal resolution of the logical bitstream */ + ogg_int64_t granule_rate_n; /* granule rate numerator */ + ogg_int64_t granule_rate_d; /* granule rate denominator */ + ogg_int64_t start_granule; /* start granule value */ + ogg_uint32_t preroll; /* preroll */ + unsigned char granule_shift; /* 1 byte value holding the granule shift */ + char *message_header_fields; /* holds all the message header fields */ + /* current total size of the message header fields, for realloc purpose, initially zero */ + ogg_uint32_t current_header_size; +} fisbone_packet; + +extern int write_ogg_page_to_file(ogg_page *og, FILE *out); +extern int add_message_header_field(fisbone_packet *fp, char *header_key, char *header_value); +/* remember to deallocate the returned ogg_packet properly */ +extern int ogg_from_fishead(fishead_packet *fp,ogg_packet *op); +extern int ogg_from_fisbone(fisbone_packet *fp,ogg_packet *op); +extern int fisbone_clear(fisbone_packet *fp); +extern int fishead_from_ogg(ogg_packet *op,fishead_packet *fp); +extern int fisbone_from_ogg(ogg_packet *op,fisbone_packet *fp); +extern int fishead_from_ogg_page(const ogg_page *og,fishead_packet *fp); +extern int fisbone_from_ogg_page(const ogg_page *og,fisbone_packet *fp); +extern int add_fishead_to_stream(ogg_stream_state *os, fishead_packet *fp); +extern int add_fisbone_to_stream(ogg_stream_state *os, fisbone_packet *fp); +extern int add_eos_packet_to_stream(ogg_stream_state *os); +extern int flush_ogg_stream_to_file(ogg_stream_state *os, FILE *out); + +#ifdef __cplusplus +} +#endif + +#endif /* _SKELETON_H */ + + + + + + diff --git a/src/test-rectinsert-data.c b/src/test-rectinsert-data.c new file mode 100644 index 0000000..9540a5f --- /dev/null +++ b/src/test-rectinsert-data.c @@ -0,0 +1,382 @@ +/****************************************************************************** +* for recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2008 Martin Nordholts * +* * +* 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 * +* * +******************************************************************************/ + +#include "config.h" +#include "test-rectinsert-data.h" + +#include "test-rectinsert-types.h" + + +// Defines to increase readability of test data +#define O FALSE +#define E TRUE + + +RectInsertTestdataEntry rectinsert_test_data[] = { + + // Test #1 + + { "Put a rect in place", + + { 2, 2, 2, 2 }, + + { O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O } }, + + + // Test #2 + + { "Put a rect in place and make sure it gets an even size and position", + + { 15, 2, 4, 3 }, + + { O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O } }, + + + // Test #3 + + { "Put a new rect within an existing rect", + + { 14, 2, 4, 2 }, + + { O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O } }, + + + // Test #4 + + { "Put a new rect over an existing rect and make sure it beocomes even", + + { 1, 1, 3, 3 }, + + { E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O } }, + + + + // Test #5 + + { "Put a new rect that partly covers an existing rect", + + { 10, 4, 6, 6 }, + + { E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,O,O,O, O,O,O,O,O, E,E,E,E,E, E,E,E,E,E, + + O,O,O,O,O, O,O,O,O,O, E,E,E,E,E, E,E,E,E,E, + O,O,O,O,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O } }, + + + // Test #6 + + { "Put new small heighted but wide rect over an existing rect area", + + { 0, 8, 20, 2 }, + + { E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,O,O,O, O,O,O,O,O, E,E,E,E,E, E,E,E,E,E, + + O,O,O,O,O, O,O,O,O,O, E,E,E,E,E, E,E,E,E,E, + O,O,O,O,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O } }, + + + // Test #7 + + { "Put new small widthed but high rect over two existing rect areas", + + { 2, 2, 2, 18 }, + + { E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,E,E,E,E, + + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,E,E,E,E, + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O } }, + + + // Test #8 + + { "Prepare for test 10", + + { 8, 14, 4, 4 }, + + { E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,E,E,E,E, + + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,E,E,E,E, + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,E,E, E,E,O,O,O, O,O,O,O,O, + + O,O,E,E,O, O,O,O,E,E, E,E,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,E,E, E,E,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,E,E, E,E,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O } }, + + + // Test #9 + + { "Prepare for test 10 (again)", + + { 16, 14, 2, 2 }, + + { E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,E,E,E,E, + + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,E,E,E,E, + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,E,E, E,E,O,O,O, O,E,E,O,O, + + O,O,E,E,O, O,O,O,E,E, E,E,O,O,O, O,E,E,O,O, + O,O,E,E,O, O,O,O,E,E, E,E,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,E,E, E,E,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O } }, + + + // Test #10 + + { "Put a rect that covers two separate rects", + + { 6, 12, 14, 8 }, + + { E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + E,E,E,E,O, O,O,O,O,O, O,O,O,O,E, E,E,E,E,E, + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,E,E,E,E, + + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,E,E,E,E, + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, E,E,E,E,E, E,O,O,O,O, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,O,O,O,O, O,O,O,O,O, O,O,O,O,O, + O,O,E,E,O, O,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + O,O,E,E,O, O,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + O,O,E,E,O, O,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + + O,O,E,E,O, O,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + O,O,E,E,O, O,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + O,O,E,E,O, O,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + O,O,E,E,O, O,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + O,O,E,E,O, O,E,E,E,E, E,E,E,E,E, E,E,E,E,E } }, + + + // Test #11 + + { "Cover the whole area", + + { 0, 0, 20, 20 }, + + { E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, + E,E,E,E,E, E,E,E,E,E, E,E,E,E,E, E,E,E,E,E } }, + + + // Mark end of tests + + { NULL, } +}; + diff --git a/src/test-rectinsert-data.h b/src/test-rectinsert-data.h new file mode 100644 index 0000000..7957b30 --- /dev/null +++ b/src/test-rectinsert-data.h @@ -0,0 +1,30 @@ +/****************************************************************************** +* for recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2008 Martin Nordholts * +* * +* 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 * +* * +******************************************************************************/ + +#ifndef TEST_RECTINSERT_DATA_H +#define TEST_RECTINSERT_DATA_H + +#include "test-rectinsert-types.h" + +extern RectInsertTestdataEntry rectinsert_test_data[]; + +#endif /* TEST_RECTINSERT_DATA_H */ diff --git a/src/test-rectinsert-types.h b/src/test-rectinsert-types.h new file mode 100644 index 0000000..b39322a --- /dev/null +++ b/src/test-rectinsert-types.h @@ -0,0 +1,41 @@ +/****************************************************************************** +* for recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2008 Martin Nordholts * +* * +* 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 * +* * +******************************************************************************/ + +#ifndef TEST_RECTINSERT_TYPES_H +#define TEST_RECTINSERT_TYPES_H + + +#include "rmd_types.h" + + +#define STATE_WIDTH 20 +#define STATE_HEIGHT 20 + + +typedef struct RectInsertTestdataEntry { + const char *description; + XRectangle new_rect; + boolean expected_state[STATE_WIDTH * STATE_HEIGHT]; +} RectInsertTestdataEntry; + + +#endif /* TEST_RECTINSERT_TYPES_H */ diff --git a/src/test-rectinsert.c b/src/test-rectinsert.c new file mode 100644 index 0000000..71d2030 --- /dev/null +++ b/src/test-rectinsert.c @@ -0,0 +1,177 @@ +/****************************************************************************** +* for recordMyDesktop * +******************************************************************************* +* * +* Copyright (C) 2008 Martin Nordholts * +* * +* 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 * +* * +******************************************************************************/ + +#include "config.h" +#include "rmd_rectinsert.h" + +#include "test-rectinsert-types.h" +#include "test-rectinsert-data.h" +#include "rmd_types.h" + + + +static void rmdSetPixel(boolean *state, int x, int y, boolean value) { + int index = y * STATE_WIDTH + x; + + // Guard against non-optimal implementations + if (index < 0 || index >= STATE_WIDTH * STATE_HEIGHT) { + return; + } + + state[y * STATE_WIDTH + x] = value; +} + +static boolean rmdGetPixel(boolean *state, int x, int y) { + int index = y * STATE_WIDTH + x; + + // Guard against non-optimal implementations + if (index < 0 || index >= STATE_WIDTH * STATE_HEIGHT) { + return FALSE; + } + + return state[y * STATE_WIDTH + x]; +} + +static void rmdWriteGeomToState(XRectangle *rect, boolean *state) { + int x, y; + + for (y = rect->y; y < rect->y + rect->height; y++) { + for (x = rect->x; x < rect->x + rect->width; x++) { + rmdSetPixel(state, x, y, TRUE); + } + } +} + +static void rmdClearState(boolean *state) { + int x, y; + + for (y = 0; y < STATE_HEIGHT; y++) { + for (x = 0; x < STATE_WIDTH; x++) { + rmdSetPixel(state, x, y, FALSE); + } + } +} + +static void rmdWarnIfNonOptimal(XRectangle *rect) { + if (rect->x < 0 || rect->x >= STATE_WIDTH || + rect->y < 0 || rect->y >= STATE_HEIGHT || + rect->width == 0 || rect->width > STATE_WIDTH || + rect->height == 0 || rect->height > STATE_HEIGHT) + { + // The rmdRectInsert() implementation is not optimal + printf(" Non-optimal rect (and rmdRectInsert() implementation) encountered!\n" + " rect x = %d, y = %d, width = %hu, height = %hu\n", + rect->x, + rect->y, + rect->width, + rect->height); + } +} + +static void GetState(RectArea *root, boolean *state) { + RectArea *current = root; + + rmdClearState(state); + + while (current) + { + rmdWarnIfNonOptimal(¤t->rect); + + rmdWriteGeomToState(¤t->rect, state); + + current = current->next; + } +} + +static boolean rmdStatesEqual(boolean *a, boolean *b) { + int x, y; + + for (y = 0; y < STATE_HEIGHT; y++) { + for (x = 0; x < STATE_WIDTH; x++) { + if (rmdGetPixel(a, x, y) != rmdGetPixel(b, x, y)) { + return FALSE; + } + } + } + + return TRUE; +} + +static void rmdPrintState(boolean *state) { + int x, y; + + for (y = 0; y < STATE_HEIGHT; y++) { + printf(" "); + + for (x = 0; x < STATE_WIDTH; x++) { + printf(rmdGetPixel(state, x, y) ? "X" : "O"); + printf(x != STATE_WIDTH - 1 ? "," : ""); + printf((x + 1) % 5 == 0 ? " " : ""); + } + + printf("\n"); + printf((y + 1) % 5 == 0 ? "\n" : ""); + } +} + +/** + * This program tests the rmdRectInsert() functionality by calling + * rmdRectInsert() with various testdata and after each call comparing + * the current state with a predefied set of expected states. + */ +int main(int argc, char **argv) { + boolean current_state[STATE_WIDTH * STATE_HEIGHT]; + RectArea *root = NULL; + int i = 0; + int result = 0; + + printf("== Testing rmdRectInsert() ==\n"); + + // Run until there we find end of tests data + while (rectinsert_test_data[i].description != NULL) { + + printf("Test #%d: %s\n", i + 1, rectinsert_test_data[i].description); + rmdRectInsert(&root, &rectinsert_test_data[i].new_rect); + GetState(root, current_state); + + if (!rmdStatesEqual(current_state, rectinsert_test_data[i].expected_state)) { + printf(" FAILURE!\n"); + printf(" Current state:\n"); + rmdPrintState(current_state); + + printf(" Expected state:\n"); + rmdPrintState(rectinsert_test_data[i].expected_state); + + // Just set to failure and keep going... + result = -1; + } + else { + printf(" PASS\n"); + } + + // Run next test + printf("\n"); + i++; + } + + return result; +} |