#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <memory.h>
#include <time.h>

#include <asm/types.h>
#include <lib/dvb/idemux.h>
#include <lib/dvb/subtitle.h>
#include <lib/base/smartptr.h>
#include <lib/base/eerror.h>
#include <lib/gdi/gpixmap.h>

void bitstream_init(struct bitstream *bit, const void *buffer, int size)
{
	bit->data = (__u8*) buffer;
	bit->size = size;
	bit->avail = 8;
	bit->consumed = 0;
}

int bitstream_get(struct bitstream *bit)
{
	int val;
	bit->avail -= bit->size;
	val = ((*bit->data) >> bit->avail) & ((1<<bit->size) - 1);
	if (!bit->avail)
	{
		bit->data++;
		bit->consumed++;
		bit->avail = 8;
	}
	return val;
}

static int extract_pts(pts_t &pts, __u8 *pkt)
{
	pkt += 7;
	int flags = *pkt++;

	pkt++; // header length

	if (flags & 0x80) /* PTS present? */
	{
			/* damn gcc bug */
		pts  = ((unsigned long long)(((pkt[0] >> 1) & 7))) << 30;
		pts |=   pkt[1] << 22;
		pts |=  (pkt[2]>>1) << 15;
		pts |=   pkt[3] << 7;
		pts |=  (pkt[5]>>1);

		return 0;
	} else
		return -1;
}

void eDVBSubtitleParser::subtitle_process_line(struct subtitle_page *page, int object_id, int line, __u8 *data, int len)
{
	struct subtitle_region *region = page->regions;
//	eDebug("line for %d:%d", page->page_id, object_id);
	while (region)
	{
		struct subtitle_region_object *object = region->region_objects;
		while (object)
		{
			if (object->object_id == object_id)
			{
				int x = object->object_horizontal_position;
				int y = object->object_vertical_position + line;
				if (x + len > region->region_width)
				{
					//eDebug("[SUB] !!!! XCLIP %d + %d > %d", x, len, region->region_width);
					len = region->region_width - x;
				}
				if (len < 0)
					break;
				if (y >= region->region_height)
				{
					//eDebug("[SUB] !!!! YCLIP %d >= %d", y, region->region_height);
					break;
				}
//				//eDebug("inserting %d bytes (into region %d)", len, region->region_id);
				memcpy((__u8*)region->region_buffer->surface->data + region->region_width * y + x, data, len);
			}
			object = object->next;
		}
		region = region->next;
	}
}

int eDVBSubtitleParser::subtitle_process_pixel_data(struct subtitle_page *page, int object_id, int *linenr, int *linep, __u8 *data)
{
	int data_type = *data++;
	static __u8 line[720];

	struct bitstream bit;
	bit.size=0;
	switch (data_type)
	{
	case 0x10: // 2bit pixel data
		bitstream_init(&bit, data, 2);
		while (1)
		{
			int len=0, col=0;
			int code = bitstream_get(&bit);
			if (code)
			{
				col = code;
				len = 1;
			} else
			{
				code = bitstream_get(&bit);
				if (!code)
				{
					code = bitstream_get(&bit);
					if (code == 1)
					{
						col = 0;
						len = 2;
					} else if (code == 2)
					{
						len = bitstream_get(&bit) << 2;
						len |= bitstream_get(&bit);
						len += 12;
						col = bitstream_get(&bit);
					} else if (code == 3)
					{
						len = bitstream_get(&bit) << 6;
						len |= bitstream_get(&bit) << 4;
						len |= bitstream_get(&bit) << 2;
						len |= bitstream_get(&bit);
						len += 29;
						col = bitstream_get(&bit);
					} else
						break;
				} else if (code==1)
				{
					col = 0;
					len = 1;
				} else if (code&2)
				{
					if (code&1)
						len = 3 + 4 + bitstream_get(&bit);
					else
						len = 3 + bitstream_get(&bit);
					col = bitstream_get(&bit);
				}
			}
			while (len && ((*linep) < 720))
			{
				line[(*linep)++] = col;
				len--;
			}
		}
		while (bit.avail != 8)
			bitstream_get(&bit);
		return bit.consumed + 1;
	case 0x11: // 4bit pixel data
		bitstream_init(&bit, data, 4);
		while (1)
		{
			int len=0, col=0;
			int code = bitstream_get(&bit);
			if (code)
			{
				col = code;
				len = 1;
			} else
			{
				code = bitstream_get(&bit);
				if (!code)
					break;
				else if (code == 0xC)
				{
					col = 0;
					len = 1;
				} else if (code == 0xD)
				{
					col = 0;
					len = 2;
				} else if (code < 8)
				{
					col = 0;
					len = (code & 7) + 2;
				} else if ((code & 0xC) == 0x8)
				{
					col = bitstream_get(&bit);
					len = (code & 3) + 4;
				} else if (code == 0xE)
				{
					len = bitstream_get(&bit) + 9;
					col = bitstream_get(&bit);
				} else if (code == 0xF)
				{
					len  = bitstream_get(&bit) << 4;
					len |= bitstream_get(&bit);
					len += 25;
					col  = bitstream_get(&bit);
				}
			}
			while (len && ((*linep) < 720))
			{
				line[(*linep)++] = col;
				len--;
			}
		}
		while (bit.avail != 8)
			bitstream_get(&bit);
		return bit.consumed + 1;
	case 0x12: // 8bit pixel data
		bitstream_init(&bit, data, 8);
		while(1)
		{
			int len=0, col=0;
			int code = bitstream_get(&bit);
			if (code)
			{
				col = code;
				len = 1;
			} else
			{
				code = bitstream_get(&bit);
				if ((code & 0x80) == 0x80)
				{
					len = code&0x7F;
					col = bitstream_get(&bit);
				} else if (code&0x7F)
				{
					len = code&0x7F;
					col = 0;
				} else
					break;
			}
			while (len && ((*linep) < 720))
			{
				line[(*linep)++] = col;
				len--;
			}
		}
		return bit.consumed + 1;
	case 0x20:  // ignore 2 -> 4bit map table
		bitstream_init(&bit, data, 4);
		for ( int i=0; i < 4; ++i )
			bitstream_get(&bit);
		break;
	case 0x21:  // ignore 2 -> 8bit map table
		bitstream_init(&bit, data, 8);
		for ( int i=0; i < 4; ++i )
			bitstream_get(&bit);
		break;
	case 0x22:  // ignore 4 -> 8bit map table
		bitstream_init(&bit, data, 8);
		for ( int i=0; i < 16; ++i )
			bitstream_get(&bit);
		break;
	case 0xF0:
		subtitle_process_line(page, object_id, *linenr, line, *linep);
/*		{
			int i;
			for (i=0; i<720; ++i)
				//eDebugNoNewLine("%d ", line[i]);
			//eDebug("");
		} */
		(*linenr)+=2; // interlaced
		*linep = 0;
//		//eDebug("[SUB] EOL");
		return 1;
	default:
		eDebug("subtitle_process_pixel_data: invalid data_type %02x", data_type);
		return -1;
	}
	return 0;
}

int eDVBSubtitleParser::subtitle_process_segment(__u8 *segment)
{
	int segment_type, page_id, segment_length, processed_length;
	if (*segment++ !=  0x0F)
	{
		eDebug("out of sync.");
		return -1;
	}
	segment_type = *segment++;
	page_id  = *segment++ << 8;
	page_id |= *segment++;
	segment_length  = *segment++ << 8;
	segment_length |= *segment++;
	if (segment_type == 0xFF)
		return segment_length + 6;
//	//eDebug("have %d bytes of segment data", segment_length);

//	//eDebug("page_id %d, segtype %02x", page_id, segment_type);

	struct subtitle_page *page, **ppage;

	page = this->pages; ppage = &this->pages;

	while (page)
	{
		if (page->page_id == page_id)
			break;
		ppage = &page->next;
		page = page->next;
	}

	processed_length = 0;

	switch (segment_type)
	{
	case 0x10: // page composition segment
	{
		int page_time_out = *segment++; processed_length++;
		int page_version_number = *segment >> 4;
		int page_state = (*segment >> 2) & 0x3;
		//eDebug("pcs with %d bytes data (%d:%d:%d)", segment_length, page_id, page_version_number, page_state);
		segment++;
		processed_length++;

		//eDebug("page time out: %d", page_time_out);
		//eDebug("page_version_number: %d" ,page_version_number);
		//eDebug("page_state: %d", page_state);

		if (!page)
		{
			//eDebug("page not found");
			page = new subtitle_page;
			page->page_regions = 0;
			page->regions = 0;
			page->page_id = page_id;
			page->cluts = 0;
			page->next = 0;
			*ppage = page;
		} else
		{
			if (page->pcs_size != segment_length)
				page->page_version_number = -1;
				// if no update, just skip this data.
			if (page->page_version_number == page_version_number)
			{
				eDebug("skip data... ");
				break;
			}
		}

//		eDebug("page updated: old: %d, new: %d", page->page_version_number, page_version_number);
			// when acquisition point or mode change: remove all displayed pages.
		if ((page_state == 1) || (page_state == 2))
		{
			while (page->page_regions)
			{
				struct subtitle_page_region *p = page->page_regions->next;
				delete page->page_regions;
				page->page_regions = p;
			}
		}

//		eDebug("new page.. (%d)", page_state);

		page->page_time_out = page_time_out;

		page->page_version_number = page_version_number;

		struct subtitle_page_region **r = &page->page_regions;

		//eDebug("%d  / %d data left", processed_length, segment_length);

			// go to last entry
		while (*r)
			r = &(*r)->next;

		while (processed_length < segment_length)
		{
			struct subtitle_page_region *pr;

				// append new entry to list
			pr = new subtitle_page_region;
			pr->next = 0;
			*r = pr;
			r = &pr->next;

			pr->region_id = *segment++; processed_length++;
			segment++; processed_length++;

			pr->region_horizontal_address  = *segment++ << 8;
			pr->region_horizontal_address |= *segment++;
			processed_length += 2;

			pr->region_vertical_address  = *segment++ << 8;
			pr->region_vertical_address |= *segment++;
			processed_length += 2;

			//eDebug("appended active region");
		}

		if (processed_length != segment_length)
			eDebug("%d != %d", processed_length, segment_length);
		break;
	}
	case 0x11: // region composition segment
	{
		int region_id = *segment++; processed_length++;
		int region_version_number = *segment >> 4;
		int region_fill_flag = (*segment >> 3) & 1;
		segment++; processed_length++;

			// if we didn't yet received the pcs for this page, drop the region
		if (!page)
		{
			eDebug("ignoring region %x, since page %02x doesn't yet exist.", region_id, page_id);
			break;
		}

		struct subtitle_region *region, **pregion;

		region = page->regions; pregion = &page->regions;

		while (region)
		{
			fflush(stdout);
			if (region->region_id == region_id)
				break;
			pregion = &region->next;
			region = region->next;
		}

		if (!region)
		{
			*pregion = region = new subtitle_region;
			region->next = 0;
		}
		else if (region->region_version_number != region_version_number)
		{
			struct subtitle_region_object *objects = region->region_objects;
			while (objects)
			{
				struct subtitle_region_object *n = objects->next;
				delete objects;
				objects = n;
			}
			if (region->region_buffer)
			{
				if (region->region_buffer->surface)
					delete region->region_buffer->surface;
				region->region_buffer=0;
			}
		}
		else
			break;

		//eDebug("region %d:%d update", page_id, region_id);

		region->region_id = region_id;
		region->region_version_number = region_version_number;

		region->region_width  = *segment++ << 8;
		region->region_width |= *segment++;
		processed_length += 2;

		region->region_height  = *segment++ << 8;
		region->region_height |= *segment++;
		processed_length += 2;

		region->region_buffer = new gPixmap(eSize(region->region_width, region->region_height), 8);

		int region_level_of_compatibility, region_depth;

		region_level_of_compatibility = (*segment >> 5) & 7;
		region_depth = (*segment++ >> 2) & 7;
		region->region_depth = (subtitle_region::depth) region_depth;
		processed_length++;

		int CLUT_id = *segment++; processed_length++;

		region->clut_id = CLUT_id;

		int region_8bit_pixel_code, region_4bit_pixel_code, region_2bit_pixel_code;
		region_8bit_pixel_code = *segment++; processed_length++;
		region_4bit_pixel_code = *segment >> 4;
		region_2bit_pixel_code = (*segment++ >> 2) & 3;
		processed_length++;

		if (!region_fill_flag)
		{
			region_2bit_pixel_code = region_4bit_pixel_code = region_8bit_pixel_code = 0;
			region_fill_flag = 1;
		}

		if (region_fill_flag)
		{
			if (region_depth == 1)
				memset(region->region_buffer->surface->data, region_2bit_pixel_code, region->region_height * region->region_width);
			else if (region_depth == 2)
				memset(region->region_buffer->surface->data, region_4bit_pixel_code, region->region_height * region->region_width);
			else if (region_depth == 3)
				memset(region->region_buffer->surface->data, region_8bit_pixel_code, region->region_height * region->region_width);
			else
				eDebug("!!!! invalid depth");
		}

		//eDebug("region %02x, version %d, %dx%d", region->region_id, region->region_version_number, region->region_width, region->region_height);

		region->region_objects = 0;
		struct subtitle_region_object **pobject = &region->region_objects;

		while (processed_length < segment_length)
		{

			struct subtitle_region_object *object;

			object = new subtitle_region_object;

			*pobject = object;
			object->next = 0;
			pobject = &object->next;

			object->object_id  = *segment++ << 8;
			object->object_id |= *segment++; processed_length += 2;

			object->object_type = *segment >> 6;
			object->object_provider_flag = (*segment >> 4) & 3;
			object->object_horizontal_position  = (*segment++ & 0xF) << 8;
			object->object_horizontal_position |= *segment++;
			processed_length += 2;

			object->object_vertical_position  = *segment++ << 8;
			object->object_vertical_position |= *segment++ ;
			processed_length += 2;

			if ((object->object_type == 1) || (object->object_type == 2))
			{
				object->foreground_pixel_value = *segment++;
				object->background_pixel_value = *segment++;
				processed_length += 2;
			}
		}

		if (processed_length != segment_length)
			eDebug("too less data! (%d < %d)", segment_length, processed_length);

		break;
	}
	case 0x12: // CLUT definition segment
	{
		int CLUT_id, CLUT_version_number;
		struct subtitle_clut *clut, **pclut;

		if (!page)
			break;

		//eDebug("CLUT: %02x", *segment);
		CLUT_id = *segment++;

		CLUT_version_number = *segment++ >> 4;
		processed_length += 2;

		//eDebug("page %d, CLUT %02x, version %d", page->page_id, CLUT_id, CLUT_version_number);

		clut = page->cluts; pclut = &page->cluts;

		while (clut)
		{
			if (clut->clut_id == CLUT_id)
				break;
			pclut = &clut->next;
			clut = clut->next;
		}

		if (!clut)
		{
			*pclut = clut = new subtitle_clut;
			clut->next = 0;
			clut->clut_id = CLUT_id;
		}
		else if (clut->CLUT_version_number == CLUT_version_number)
			break;

		clut->CLUT_version_number=CLUT_version_number;
		clut->size_2 = clut->size_4 = clut->size_8 = 0;

			/* invalidate CLUT if updated. */
		if ((this->current_clut_page_id == page_id) && (this->current_clut_id == CLUT_id))
			this->current_clut_id = -1;

		//eDebug("new clut");
		while (processed_length < segment_length)
		{
			int CLUT_entry_id, entry_CLUT_flag, full_range;
			int v_Y, v_Cr, v_Cb, v_T;

			CLUT_entry_id = *segment++;
			full_range = *segment & 1;
			entry_CLUT_flag = (*segment++ & 0xE0) >> 5;
			processed_length += 2;

			if (full_range)
			{
				v_Y  = *segment++;
				v_Cr = *segment++;
				v_Cb = *segment++;
				v_T  = *segment++;
				processed_length += 4;
			} else
			{
				v_Y   = *segment & 0xFC;
				v_Cr  = (*segment++ & 3) << 6;
				v_Cr |= (*segment & 0xC0) >> 2;
				v_Cb  = (*segment & 0x3C) << 2;
				v_T   = (*segment++ & 3) << 6;
				processed_length += 2;
			}

			if (entry_CLUT_flag & 1) // 8bit
			{
				ASSERT(CLUT_entry_id < 256);
				++clut->size_8;
				clut->entries_8bit[CLUT_entry_id].Y = v_Y;
				clut->entries_8bit[CLUT_entry_id].Cr = v_Cr;
				clut->entries_8bit[CLUT_entry_id].Cb = v_Cb;
				clut->entries_8bit[CLUT_entry_id].T = v_T;
			}
			if (entry_CLUT_flag & 2) // 4bit
			{
				ASSERT(CLUT_entry_id < 16);
				++clut->size_4;
				clut->entries_4bit[CLUT_entry_id].Y = v_Y;
				clut->entries_4bit[CLUT_entry_id].Cr = v_Cr;
				clut->entries_4bit[CLUT_entry_id].Cb = v_Cb;
				clut->entries_4bit[CLUT_entry_id].T = v_T;
			}
			if (entry_CLUT_flag & 4) // 2bit
			{
				ASSERT(CLUT_entry_id < 4);
				++clut->size_2;
				clut->entries_2bit[CLUT_entry_id].Y = v_Y;
				clut->entries_2bit[CLUT_entry_id].Cr = v_Cr;
				clut->entries_2bit[CLUT_entry_id].Cb = v_Cb;
				clut->entries_2bit[CLUT_entry_id].T = v_T;
			}
			//eDebug("  %04x %02x %02x %02x %02x", CLUT_entry_id, v_Y, v_Cb, v_Cr, v_T);
		}
		break;
	}
	case 0x13: // object data segment
	{
		int object_id, object_version_number, object_coding_method, non_modifying_color_flag;

		object_id  = *segment++ << 8;
		object_id |= *segment++;
		processed_length += 2;

		object_version_number = *segment >> 4;
		object_coding_method  = (*segment >> 2) & 3;
		non_modifying_color_flag = (*segment++ >> 1) & 1;
		processed_length++;

		//eDebug("object id %04x, version %d, object_coding_method %d (page_id %d)", object_id, object_version_number, object_coding_method, page_id);

		if (object_coding_method == 0)
		{
			int top_field_data_blocklength, bottom_field_data_blocklength;
			int i, line, linep;

			top_field_data_blocklength  = *segment++ << 8;
			top_field_data_blocklength |= *segment++;

			bottom_field_data_blocklength  = *segment++ << 8;
			bottom_field_data_blocklength |= *segment++;
			//eDebug("%d / %d bytes", top_field_data_blocklength, bottom_field_data_blocklength);
			processed_length += 4;

			i = 0;
			line = 0;
			linep = 0;
			while (i < top_field_data_blocklength)
			{
				int len;
				len = subtitle_process_pixel_data(page, object_id, &line, &linep, segment);
				if (len < 0)
					return -1;
				segment += len;
				processed_length += len;
				i += len;
			}

			line = 1;
			linep = 0;

			if (bottom_field_data_blocklength)
			{
				i = 0;
				while (i < bottom_field_data_blocklength)
				{
					int len;
					len = subtitle_process_pixel_data(page, object_id, &line, &linep, segment);
					if (len < 0)
						return -1;
					segment += len;
					processed_length += len;
					i += len;
				}
			}
			else if (top_field_data_blocklength)
				eDebug("!!!! unimplemented: no bottom field! (%d : %d)", top_field_data_blocklength, bottom_field_data_blocklength);

			if ((top_field_data_blocklength + bottom_field_data_blocklength) & 1)
			{
				segment++; processed_length++;
			}
		}
		else if (object_coding_method == 1)
			eDebug("---- object_coding_method 1 unsupported!");

		break;
	}
	case 0x80: // end of display set segment
	{
//		eDebug("end of display set segment");
		subtitle_redraw_all();
	}
	case 0xFF: // stuffing
		break;
	default:
		eDebug("unhandled segment type %02x", segment_type);
	}

	return segment_length + 6;
}

void eDVBSubtitleParser::subtitle_process_pes(__u8 *pkt, int len)
{
	eDebug("subtitle_process_pes");
	if (!extract_pts(show_time, pkt))
	{
		pkt += 6; len -= 6;
		// skip PES header
		pkt++; len--;
		pkt++; len--;

		int hdr_len = *pkt++; len--;

		pkt+=hdr_len; len-=hdr_len;

		if (*pkt != 0x20)
		{
			//eDebug("data identifier is 0x%02x, but not 0x20", *pkt);
			return;
		}
		pkt++; len--; // data identifier
		*pkt++; len--; // stream id;

		if (len <= 0)
		{
			//eDebug("no data left (%d)", len);
			return;
		}

		while (len && *pkt == 0x0F)
		{
			int l = subtitle_process_segment(pkt);
			if (l < 0)
				break;
			pkt += l;
			len -= l;
		}
	//	if (len && *pkt != 0xFF)
	//		eDebug("strange data at the end");
	}
	else
		eDebug("dvb subtitle packet without PTS.. ignore!!");
}

void eDVBSubtitleParser::subtitle_clear_screen()
{
		/* clear bbox */
	int y;

	//eDebug("BBOX clear %d:%d -> %d:%d", this->bbox_left, this->bbox_top, this->bbox_right, this->bbox_bottom);

	// do not draw when anyone has locked the
	// framebuffer ( non enigma plugins... )
	this->bbox_right = 720;
	if (this->bbox_right > this->bbox_left)
		for (y=this->bbox_top; y < this->bbox_bottom; ++y)
			; // TODO fixmee clear subtitle screen

	this->bbox_right = 0;
	this->bbox_left = this->screen_width;
	this->bbox_top = this->screen_height;
	this->bbox_bottom = 0;
}

void eDVBSubtitleParser::subtitle_redraw_all()
{
#if 1
	struct subtitle_page *page = this->pages;
	if ( page )
	{
		struct subtitle_page_region *region = page->page_regions;
		if ( region )
			subtitle_clear_screen();
	}
	while(page)
	{
		subtitle_redraw(page->page_id);
		page = page->next;
	}
#else
	subtitle_clear_screen();

	struct subtitle_page *page = this->pages;
	//eDebug("----------- end of display set");
	//eDebug("active pages:");
	while (page)
	{
		//eDebug("  page_id %02x", page->page_id);
		//eDebug("  page_version_number: %d", page->page_version_number);
		//eDebug("  active regions:");
		{
			struct subtitle_page_region *region = page->page_regions;
			while (region)
			{
				//eDebug("    region_id: %04x", region->region_id);
				//eDebug("    region_horizontal_address: %d", region->region_horizontal_address);
				//eDebug("    region_vertical_address: %d", region->region_vertical_address);

				region = region->next;
			}
		}

		subtitle_redraw(page->page_id);
		//eDebug("defined regions:");
		struct subtitle_region *region = page->regions;
		while (region)
		{
			//eDebug("  region_id %04x, version %d, %dx%d", region->region_id, region->region_version_number, region->region_width, region->region_height);

			struct subtitle_region_object *object = region->region_objects;
			while (object)
			{
				//eDebug("  object %02x, type %d, %d:%d", object->object_id, object->object_type, object->object_horizontal_position, object->object_vertical_position);
				object = object->next;
			}
			region = region->next;
		}
		page = page->next;
	}
#endif
}

void eDVBSubtitleParser::subtitle_reset()
{
	while (struct subtitle_page *page = this->pages)
	{
			/* free page regions */
		while (page->page_regions)
		{
			struct subtitle_page_region *p = page->page_regions->next;
			delete page->page_regions;
			page->page_regions = p;
		}
			/* free regions */
		while (page->regions)
		{
			struct subtitle_region *region = page->regions;

			while (region->region_objects)
			{
				struct subtitle_region_object *obj = region->region_objects;
				region->region_objects = obj->next;
				delete obj;
			}

			if (region->region_buffer)
			{
				if (region->region_buffer->surface)
					delete region->region_buffer->surface;
				region->region_buffer=0;
			}

			page->regions = region->next;
			delete region;
		}

			/* free CLUTs */
		while (page->cluts)
		{
			struct subtitle_clut *clut = page->cluts;
			page->cluts = clut->next;
			delete clut;
		}

		this->pages = page->next;
		delete page;
	}
}

void eDVBSubtitleParser::subtitle_redraw(int page_id)
{
	struct subtitle_page *page = this->pages;

	//eDebug("displaying page id %d", page_id);

	while (page)
	{
		if (page->page_id == page_id)
			break;
		page = page->next;
	}
	if (!page)
	{
		//eDebug("page not found");
		return;
	}


	//eDebug("iterating regions..");
		/* iterate all regions in this pcs */
	struct subtitle_page_region *region = page->page_regions;
	while (region)
	{
		//eDebug("region %d", region->region_id);
			/* find corresponding region */
		struct subtitle_region *reg = page->regions;
		while (reg)
		{
			if (reg->region_id == region->region_id)
				break;
			reg = reg->next;
		}
		if (reg)
		{
			int y;
			//eDebug("copy region %d to %d, %d", region->region_id, region->region_horizontal_address, region->region_vertical_address);

			int x0 = region->region_horizontal_address;
			int y0 = region->region_vertical_address;
			int x1 = x0 + reg->region_width;
			int y1 = y0 + reg->region_height;

			if ((x0 < 0) || (y0 < 0) || (x0 > this->screen_width) || (x0 > this->screen_height))
				continue;

				/* adjust bbox */
			if (x0 < this->bbox_left)
				this->bbox_left = x0;
			if (y0 < this->bbox_top)
				this->bbox_top = y0;
			if (x1 > this->bbox_right)
				this->bbox_right = x1;
			if (y1 > this->bbox_bottom)
				this->bbox_bottom = y1;

			int timeout = page->page_time_out;

			/* find corresponding clut */
			struct subtitle_clut *clut = page->cluts;
			while (clut)
			{
			//eDebug("have %d, want %d", clut->clut_id, main_clut_id);
				if (clut->clut_id == reg->clut_id)
					break;
				clut = clut->next;
			}
			if (clut)
			{
				// TODO fill region->surface->clut !!!!!
			}
			else
			{
				// apply default clut depending on region->region_depth
				// TODO fill region->surface->clut !!!!!
			}
			// TODO Blit Region Pixmap !!!
			eDebug("blit region");
		}
		else
			eDebug("region not found");
		region = region->next;
	}
	//eDebug("schon gut.");
}

DEFINE_REF(eDVBSubtitleParser);

eDVBSubtitleParser::eDVBSubtitleParser(iDVBDemux *demux)
{
	setStreamID(0xBD);

	if (demux->createPESReader(eApp, m_pes_reader))
		eDebug("failed to create dvb subtitle PES reader!");
	else
		m_pes_reader->connectRead(slot(*this, &eDVBSubtitleParser::processData), m_read_connection);
}

eDVBSubtitleParser::~eDVBSubtitleParser()
{
	subtitle_reset();
}

int eDVBSubtitleParser::start(int pid)
{
#if 0
	eDebug("eDVBSubtitleParser::start(%04x)", pid);
	if (m_pes_reader)
		return m_pes_reader->start(pid);
	else
		return -1;
#endif
}

void eDVBSubtitleParser::connectNewRegion(const Slot1<void, const eDVBSubtitleRegion&> &slot, ePtr<eConnection> &connection)
{
	connection = new eConnection(this, m_new_subtitle_region.connect(slot));
}