*: drop {gtk,qt}-recordmydesktop subdirs

This restores the recordmydesktop/ subdir as root from the mirror I
cloned by fork from.

I have no particular interest in the gtk/qt frontends and it doesn't
appear they were part of a single tree in the past.  But I will
probably preserve backwards compatibility of the cli so they can
continue to work with this fork installed.

1 files changed, 0 insertions, 336 deletions

diff --git a/recordmydesktop/src/rmd_load_cache.c b/recordmydesktop/src/rmd_load_cache.c
deleted file mode 100644
index 8ca37f6..0000000
--- a/recordmydesktop/src/rmd_load_cache.c
+++ /dev/null
@@ -1,336 +0,0 @@
-/******************************************************************************
-*                            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);
-}