WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavcodec/dvbsubdec.c

Rev	Author	Line No.	Line
6147	serge	1	/*
		2	* DVB subtitle decoding
		3	* Copyright (c) 2005 Ian Caulfield
		4	*
		5	* This file is part of FFmpeg.
		6	*
		7	* FFmpeg is free software; you can redistribute it and/or
		8	* modify it under the terms of the GNU Lesser General Public
		9	* License as published by the Free Software Foundation; either
		10	* version 2.1 of the License, or (at your option) any later version.
		11	*
		12	* FFmpeg is distributed in the hope that it will be useful,
		13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		15	* Lesser General Public License for more details.
		16	*
		17	* You should have received a copy of the GNU Lesser General Public
		18	* License along with FFmpeg; if not, write to the Free Software
		19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		20	*/
		21
		22	#include "avcodec.h"
		23	#include "get_bits.h"
		24	#include "bytestream.h"
		25	#include "internal.h"
		26	#include "libavutil/colorspace.h"
		27	#include "libavutil/opt.h"
		28
		29	#define DVBSUB_PAGE_SEGMENT 0x10
		30	#define DVBSUB_REGION_SEGMENT 0x11
		31	#define DVBSUB_CLUT_SEGMENT 0x12
		32	#define DVBSUB_OBJECT_SEGMENT 0x13
		33	#define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14
		34	#define DVBSUB_DISPLAY_SEGMENT 0x80
		35
		36	#define cm (ff_crop_tab + MAX_NEG_CROP)
		37
		38	#ifdef DEBUG
		39	#if 0
		40	static void png_save(const char filename, uint8_t bitmap, int w, int h,
		41	uint32_t *rgba_palette)
		42	{
		43	int x, y, v;
		44	FILE *f;
		45	char fname[40], fname2[40];
		46	char command[1024];
		47
		48	snprintf(fname, 40, "%s.ppm", filename);
		49
		50	f = fopen(fname, "w");
		51	if (!f) {
		52	perror(fname);
		53	return;
		54	}
		55	fprintf(f, "P6\n"
		56	"%d %d\n"
		57	"%d\n",
		58	w, h, 255);
		59	for(y = 0; y < h; y++) {
		60	for(x = 0; x < w; x++) {
		61	v = rgba_palette[bitmap[y * w + x]];
		62	putc((v >> 16) & 0xff, f);
		63	putc((v >> 8) & 0xff, f);
		64	putc((v >> 0) & 0xff, f);
		65	}
		66	}
		67	fclose(f);
		68
		69
		70	snprintf(fname2, 40, "%s-a.pgm", filename);
		71
		72	f = fopen(fname2, "w");
		73	if (!f) {
		74	perror(fname2);
		75	return;
		76	}
		77	fprintf(f, "P5\n"
		78	"%d %d\n"
		79	"%d\n",
		80	w, h, 255);
		81	for(y = 0; y < h; y++) {
		82	for(x = 0; x < w; x++) {
		83	v = rgba_palette[bitmap[y * w + x]];
		84	putc((v >> 24) & 0xff, f);
		85	}
		86	}
		87	fclose(f);
		88
		89	snprintf(command, 1024, "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
		90	system(command);
		91
		92	snprintf(command, 1024, "rm %s %s", fname, fname2);
		93	system(command);
		94	}
		95	#endif
		96
		97	static void png_save2(const char filename, uint32_t bitmap, int w, int h)
		98	{
		99	int x, y, v;
		100	FILE *f;
		101	char fname[40], fname2[40];
		102	char command[1024];
		103
		104	snprintf(fname, sizeof(fname), "%s.ppm", filename);
		105
		106	f = fopen(fname, "w");
		107	if (!f) {
		108	perror(fname);
		109	return;
		110	}
		111	fprintf(f, "P6\n"
		112	"%d %d\n"
		113	"%d\n",
		114	w, h, 255);
		115	for(y = 0; y < h; y++) {
		116	for(x = 0; x < w; x++) {
		117	v = bitmap[y * w + x];
		118	putc((v >> 16) & 0xff, f);
		119	putc((v >> 8) & 0xff, f);
		120	putc((v >> 0) & 0xff, f);
		121	}
		122	}
		123	fclose(f);
		124
		125
		126	snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);
		127
		128	f = fopen(fname2, "w");
		129	if (!f) {
		130	perror(fname2);
		131	return;
		132	}
		133	fprintf(f, "P5\n"
		134	"%d %d\n"
		135	"%d\n",
		136	w, h, 255);
		137	for(y = 0; y < h; y++) {
		138	for(x = 0; x < w; x++) {
		139	v = bitmap[y * w + x];
		140	putc((v >> 24) & 0xff, f);
		141	}
		142	}
		143	fclose(f);
		144
		145	snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
		146	system(command);
		147
		148	snprintf(command, sizeof(command), "rm %s %s", fname, fname2);
		149	system(command);
		150	}
		151	#endif
		152
		153	#define RGBA(r,g,b,a) (((unsigned)(a) << 24) \| ((r) << 16) \| ((g) << 8) \| (b))
		154
		155	typedef struct DVBSubCLUT {
		156	int id;
		157	int version;
		158
		159	uint32_t clut4[4];
		160	uint32_t clut16[16];
		161	uint32_t clut256[256];
		162
		163	struct DVBSubCLUT *next;
		164	} DVBSubCLUT;
		165
		166	static DVBSubCLUT default_clut;
		167
		168	typedef struct DVBSubObjectDisplay {
		169	int object_id;
		170	int region_id;
		171
		172	int x_pos;
		173	int y_pos;
		174
		175	int fgcolor;
		176	int bgcolor;
		177
		178	struct DVBSubObjectDisplay *region_list_next;
		179	struct DVBSubObjectDisplay *object_list_next;
		180	} DVBSubObjectDisplay;
		181
		182	typedef struct DVBSubObject {
		183	int id;
		184	int version;
		185
		186	int type;
		187
		188	DVBSubObjectDisplay *display_list;
		189
		190	struct DVBSubObject *next;
		191	} DVBSubObject;
		192
		193	typedef struct DVBSubRegionDisplay {
		194	int region_id;
		195
		196	int x_pos;
		197	int y_pos;
		198
		199	struct DVBSubRegionDisplay *next;
		200	} DVBSubRegionDisplay;
		201
		202	typedef struct DVBSubRegion {
		203	int id;
		204	int version;
		205
		206	int width;
		207	int height;
		208	int depth;
		209
		210	int clut;
		211	int bgcolor;
		212
		213	uint8_t *pbuf;
		214	int buf_size;
		215	int dirty;
		216
		217	DVBSubObjectDisplay *display_list;
		218
		219	struct DVBSubRegion *next;
		220	} DVBSubRegion;
		221
		222	typedef struct DVBSubDisplayDefinition {
		223	int version;
		224
		225	int x;
		226	int y;
		227	int width;
		228	int height;
		229	} DVBSubDisplayDefinition;
		230
		231	typedef struct DVBSubContext {
		232	AVClass *class;
		233	int composition_id;
		234	int ancillary_id;
		235
		236	int version;
		237	int time_out;
		238	int compute_edt; /**< if 1 end display time calculated using pts
		239	if 0 (Default) calculated using time out */
		240	int compute_clut;
		241	int substream;
		242	int64_t prev_start;
		243	DVBSubRegion *region_list;
		244	DVBSubCLUT *clut_list;
		245	DVBSubObject *object_list;
		246
		247	DVBSubRegionDisplay *display_list;
		248	DVBSubDisplayDefinition *display_definition;
		249	} DVBSubContext;
		250
		251
		252	static DVBSubObject* get_object(DVBSubContext *ctx, int object_id)
		253	{
		254	DVBSubObject *ptr = ctx->object_list;
		255
		256	while (ptr && ptr->id != object_id) {
		257	ptr = ptr->next;
		258	}
		259
		260	return ptr;
		261	}
		262
		263	static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id)
		264	{
		265	DVBSubCLUT *ptr = ctx->clut_list;
		266
		267	while (ptr && ptr->id != clut_id) {
		268	ptr = ptr->next;
		269	}
		270
		271	return ptr;
		272	}
		273
		274	static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id)
		275	{
		276	DVBSubRegion *ptr = ctx->region_list;
		277
		278	while (ptr && ptr->id != region_id) {
		279	ptr = ptr->next;
		280	}
		281
		282	return ptr;
		283	}
		284
		285	static void delete_region_display_list(DVBSubContext ctx, DVBSubRegion region)
		286	{
		287	DVBSubObject object, obj2, **obj2_ptr;
		288	DVBSubObjectDisplay display, obj_disp, **obj_disp_ptr;
		289
		290	while (region->display_list) {
		291	display = region->display_list;
		292
		293	object = get_object(ctx, display->object_id);
		294
		295	if (object) {
		296	obj_disp_ptr = &object->display_list;
		297	obj_disp = *obj_disp_ptr;
		298
		299	while (obj_disp && obj_disp != display) {
		300	obj_disp_ptr = &obj_disp->object_list_next;
		301	obj_disp = *obj_disp_ptr;
		302	}
		303
		304	if (obj_disp) {
		305	*obj_disp_ptr = obj_disp->object_list_next;
		306
		307	if (!object->display_list) {
		308	obj2_ptr = &ctx->object_list;
		309	obj2 = *obj2_ptr;
		310
		311	while (obj2 != object) {
		312	av_assert0(obj2);
		313	obj2_ptr = &obj2->next;
		314	obj2 = *obj2_ptr;
		315	}
		316
		317	*obj2_ptr = obj2->next;
		318
		319	av_freep(&obj2);
		320	}
		321	}
		322	}
		323
		324	region->display_list = display->region_list_next;
		325
		326	av_freep(&display);
		327	}
		328
		329	}
		330
		331	static void delete_cluts(DVBSubContext *ctx)
		332	{
		333	while (ctx->clut_list) {
		334	DVBSubCLUT *clut = ctx->clut_list;
		335
		336	ctx->clut_list = clut->next;
		337
		338	av_freep(&clut);
		339	}
		340	}
		341
		342	static void delete_objects(DVBSubContext *ctx)
		343	{
		344	while (ctx->object_list) {
		345	DVBSubObject *object = ctx->object_list;
		346
		347	ctx->object_list = object->next;
		348
		349	av_freep(&object);
		350	}
		351	}
		352
		353	static void delete_regions(DVBSubContext *ctx)
		354	{
		355	while (ctx->region_list) {
		356	DVBSubRegion *region = ctx->region_list;
		357
		358	ctx->region_list = region->next;
		359
		360	delete_region_display_list(ctx, region);
		361
		362	av_freep(®ion->pbuf);
		363	av_freep(®ion);
		364	}
		365	}
		366
		367	static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)
		368	{
		369	int i, r, g, b, a = 0;
		370	DVBSubContext *ctx = avctx->priv_data;
		371
		372	if (ctx->substream < 0) {
		373	ctx->composition_id = -1;
		374	ctx->ancillary_id = -1;
		375	} else if (!avctx->extradata \|\| (avctx->extradata_size < 4) \|\| ((avctx->extradata_size % 5 != 0) && (avctx->extradata_size != 4))) {
		376	av_log(avctx, AV_LOG_WARNING, "Invalid DVB subtitles stream extradata!\n");
		377	ctx->composition_id = -1;
		378	ctx->ancillary_id = -1;
		379	} else {
		380	if (avctx->extradata_size > 5*ctx->substream + 2) {
		381	ctx->composition_id = AV_RB16(avctx->extradata + 5*ctx->substream);
		382	ctx->ancillary_id = AV_RB16(avctx->extradata + 5*ctx->substream + 2);
		383	} else {
		384	av_log(avctx, AV_LOG_WARNING, "Selected DVB subtitles sub-stream %d is not available\n", ctx->substream);
		385	ctx->composition_id = AV_RB16(avctx->extradata);
		386	ctx->ancillary_id = AV_RB16(avctx->extradata + 2);
		387	}
		388	}
		389
		390	ctx->version = -1;
		391	ctx->prev_start = AV_NOPTS_VALUE;
		392
		393	default_clut.id = -1;
		394	default_clut.next = NULL;
		395
		396	default_clut.clut4[0] = RGBA( 0, 0, 0, 0);
		397	default_clut.clut4[1] = RGBA(255, 255, 255, 255);
		398	default_clut.clut4[2] = RGBA( 0, 0, 0, 255);
		399	default_clut.clut4[3] = RGBA(127, 127, 127, 255);
		400
		401	default_clut.clut16[0] = RGBA( 0, 0, 0, 0);
		402	for (i = 1; i < 16; i++) {
		403	if (i < 8) {
		404	r = (i & 1) ? 255 : 0;
		405	g = (i & 2) ? 255 : 0;
		406	b = (i & 4) ? 255 : 0;
		407	} else {
		408	r = (i & 1) ? 127 : 0;
		409	g = (i & 2) ? 127 : 0;
		410	b = (i & 4) ? 127 : 0;
		411	}
		412	default_clut.clut16[i] = RGBA(r, g, b, 255);
		413	}
		414
		415	default_clut.clut256[0] = RGBA( 0, 0, 0, 0);
		416	for (i = 1; i < 256; i++) {
		417	if (i < 8) {
		418	r = (i & 1) ? 255 : 0;
		419	g = (i & 2) ? 255 : 0;
		420	b = (i & 4) ? 255 : 0;
		421	a = 63;
		422	} else {
		423	switch (i & 0x88) {
		424	case 0x00:
		425	r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
		426	g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
		427	b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
		428	a = 255;
		429	break;
		430	case 0x08:
		431	r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
		432	g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
		433	b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
		434	a = 127;
		435	break;
		436	case 0x80:
		437	r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
		438	g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
		439	b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
		440	a = 255;
		441	break;
		442	case 0x88:
		443	r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
		444	g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
		445	b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
		446	a = 255;
		447	break;
		448	}
		449	}
		450	default_clut.clut256[i] = RGBA(r, g, b, a);
		451	}
		452
		453	return 0;
		454	}
		455
		456	static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
		457	{
		458	DVBSubContext *ctx = avctx->priv_data;
		459	DVBSubRegionDisplay *display;
		460
		461	delete_regions(ctx);
		462
		463	delete_objects(ctx);
		464
		465	delete_cluts(ctx);
		466
		467	av_freep(&ctx->display_definition);
		468
		469	while (ctx->display_list) {
		470	display = ctx->display_list;
		471	ctx->display_list = display->next;
		472
		473	av_freep(&display);
		474	}
		475
		476	return 0;
		477	}
		478
		479	static int dvbsub_read_2bit_string(AVCodecContext *avctx,
		480	uint8_t *destbuf, int dbuf_len,
		481	const uint8_t **srcbuf, int buf_size,
		482	int non_mod, uint8_t *map_table, int x_pos)
		483	{
		484	GetBitContext gb;
		485
		486	int bits;
		487	int run_length;
		488	int pixels_read = x_pos;
		489
		490	init_get_bits(&gb, *srcbuf, buf_size << 3);
		491
		492	destbuf += x_pos;
		493
		494	while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
		495	bits = get_bits(&gb, 2);
		496
		497	if (bits) {
		498	if (non_mod != 1 \|\| bits != 1) {
		499	if (map_table)
		500	*destbuf++ = map_table[bits];
		501	else
		502	*destbuf++ = bits;
		503	}
		504	pixels_read++;
		505	} else {
		506	bits = get_bits1(&gb);
		507	if (bits == 1) {
		508	run_length = get_bits(&gb, 3) + 3;
		509	bits = get_bits(&gb, 2);
		510
		511	if (non_mod == 1 && bits == 1)
		512	pixels_read += run_length;
		513	else {
		514	if (map_table)
		515	bits = map_table[bits];
		516	while (run_length-- > 0 && pixels_read < dbuf_len) {
		517	*destbuf++ = bits;
		518	pixels_read++;
		519	}
		520	}
		521	} else {
		522	bits = get_bits1(&gb);
		523	if (bits == 0) {
		524	bits = get_bits(&gb, 2);
		525	if (bits == 2) {
		526	run_length = get_bits(&gb, 4) + 12;
		527	bits = get_bits(&gb, 2);
		528
		529	if (non_mod == 1 && bits == 1)
		530	pixels_read += run_length;
		531	else {
		532	if (map_table)
		533	bits = map_table[bits];
		534	while (run_length-- > 0 && pixels_read < dbuf_len) {
		535	*destbuf++ = bits;
		536	pixels_read++;
		537	}
		538	}
		539	} else if (bits == 3) {
		540	run_length = get_bits(&gb, 8) + 29;
		541	bits = get_bits(&gb, 2);
		542
		543	if (non_mod == 1 && bits == 1)
		544	pixels_read += run_length;
		545	else {
		546	if (map_table)
		547	bits = map_table[bits];
		548	while (run_length-- > 0 && pixels_read < dbuf_len) {
		549	*destbuf++ = bits;
		550	pixels_read++;
		551	}
		552	}
		553	} else if (bits == 1) {
		554	if (map_table)
		555	bits = map_table[0];
		556	else
		557	bits = 0;
		558	run_length = 2;
		559	while (run_length-- > 0 && pixels_read < dbuf_len) {
		560	*destbuf++ = bits;
		561	pixels_read++;
		562	}
		563	} else {
		564	(*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
		565	return pixels_read;
		566	}
		567	} else {
		568	if (map_table)
		569	bits = map_table[0];
		570	else
		571	bits = 0;
		572	*destbuf++ = bits;
		573	pixels_read++;
		574	}
		575	}
		576	}
		577	}
		578
		579	if (get_bits(&gb, 6))
		580	av_log(avctx, AV_LOG_ERROR, "line overflow\n");
		581
		582	(*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
		583
		584	return pixels_read;
		585	}
		586
		587	static int dvbsub_read_4bit_string(AVCodecContext avctx, uint8_t destbuf, int dbuf_len,
		588	const uint8_t **srcbuf, int buf_size,
		589	int non_mod, uint8_t *map_table, int x_pos)
		590	{
		591	GetBitContext gb;
		592
		593	int bits;
		594	int run_length;
		595	int pixels_read = x_pos;
		596
		597	init_get_bits(&gb, *srcbuf, buf_size << 3);
		598
		599	destbuf += x_pos;
		600
		601	while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
		602	bits = get_bits(&gb, 4);
		603
		604	if (bits) {
		605	if (non_mod != 1 \|\| bits != 1) {
		606	if (map_table)
		607	*destbuf++ = map_table[bits];
		608	else
		609	*destbuf++ = bits;
		610	}
		611	pixels_read++;
		612	} else {
		613	bits = get_bits1(&gb);
		614	if (bits == 0) {
		615	run_length = get_bits(&gb, 3);
		616
		617	if (run_length == 0) {
		618	(*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
		619	return pixels_read;
		620	}
		621
		622	run_length += 2;
		623
		624	if (map_table)
		625	bits = map_table[0];
		626	else
		627	bits = 0;
		628
		629	while (run_length-- > 0 && pixels_read < dbuf_len) {
		630	*destbuf++ = bits;
		631	pixels_read++;
		632	}
		633	} else {
		634	bits = get_bits1(&gb);
		635	if (bits == 0) {
		636	run_length = get_bits(&gb, 2) + 4;
		637	bits = get_bits(&gb, 4);
		638
		639	if (non_mod == 1 && bits == 1)
		640	pixels_read += run_length;
		641	else {
		642	if (map_table)
		643	bits = map_table[bits];
		644	while (run_length-- > 0 && pixels_read < dbuf_len) {
		645	*destbuf++ = bits;
		646	pixels_read++;
		647	}
		648	}
		649	} else {
		650	bits = get_bits(&gb, 2);
		651	if (bits == 2) {
		652	run_length = get_bits(&gb, 4) + 9;
		653	bits = get_bits(&gb, 4);
		654
		655	if (non_mod == 1 && bits == 1)
		656	pixels_read += run_length;
		657	else {
		658	if (map_table)
		659	bits = map_table[bits];
		660	while (run_length-- > 0 && pixels_read < dbuf_len) {
		661	*destbuf++ = bits;
		662	pixels_read++;
		663	}
		664	}
		665	} else if (bits == 3) {
		666	run_length = get_bits(&gb, 8) + 25;
		667	bits = get_bits(&gb, 4);
		668
		669	if (non_mod == 1 && bits == 1)
		670	pixels_read += run_length;
		671	else {
		672	if (map_table)
		673	bits = map_table[bits];
		674	while (run_length-- > 0 && pixels_read < dbuf_len) {
		675	*destbuf++ = bits;
		676	pixels_read++;
		677	}
		678	}
		679	} else if (bits == 1) {
		680	if (map_table)
		681	bits = map_table[0];
		682	else
		683	bits = 0;
		684	run_length = 2;
		685	while (run_length-- > 0 && pixels_read < dbuf_len) {
		686	*destbuf++ = bits;
		687	pixels_read++;
		688	}
		689	} else {
		690	if (map_table)
		691	bits = map_table[0];
		692	else
		693	bits = 0;
		694	*destbuf++ = bits;
		695	pixels_read ++;
		696	}
		697	}
		698	}
		699	}
		700	}
		701
		702	if (get_bits(&gb, 8))
		703	av_log(avctx, AV_LOG_ERROR, "line overflow\n");
		704
		705	(*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
		706
		707	return pixels_read;
		708	}
		709
		710	static int dvbsub_read_8bit_string(AVCodecContext *avctx,
		711	uint8_t *destbuf, int dbuf_len,
		712	const uint8_t **srcbuf, int buf_size,
		713	int non_mod, uint8_t *map_table, int x_pos)
		714	{
		715	const uint8_t sbuf_end = (srcbuf) + buf_size;
		716	int bits;
		717	int run_length;
		718	int pixels_read = x_pos;
		719
		720	destbuf += x_pos;
		721
		722	while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {
		723	bits = (srcbuf)++;
		724
		725	if (bits) {
		726	if (non_mod != 1 \|\| bits != 1) {
		727	if (map_table)
		728	*destbuf++ = map_table[bits];
		729	else
		730	*destbuf++ = bits;
		731	}
		732	pixels_read++;
		733	} else {
		734	bits = (srcbuf)++;
		735	run_length = bits & 0x7f;
		736	if ((bits & 0x80) == 0) {
		737	if (run_length == 0) {
		738	return pixels_read;
		739	}
		740
		741	bits = 0;
		742	} else {
		743	bits = (srcbuf)++;
		744	}
		745	if (non_mod == 1 && bits == 1)
		746	pixels_read += run_length;
		747	else {
		748	if (map_table)
		749	bits = map_table[bits];
		750	while (run_length-- > 0 && pixels_read < dbuf_len) {
		751	*destbuf++ = bits;
		752	pixels_read++;
		753	}
		754	}
		755	}
		756	}
		757
		758	if ((srcbuf)++)
		759	av_log(avctx, AV_LOG_ERROR, "line overflow\n");
		760
		761	return pixels_read;
		762	}
		763
		764	static void compute_default_clut(AVPicture *frame, int w, int h)
		765	{
		766	uint8_t list[256] = {0};
		767	uint8_t list_inv[256];
		768	int counttab[256] = {0};
		769	int count, i, x, y;
		770
		771	#define V(x,y) frame->data[0][(x) + (y)*frame->linesize[0]]
		772	for (y = 0; y
		773	for (x = 0; x
		774	int v = V(x,y) + 1;
		775	int vl = x ? V(x-1,y) + 1 : 0;
		776	int vr = x+1
		777	int vt = y ? V(x,y-1) + 1 : 0;
		778	int vb = y+1
		779	counttab[v-1] += !!((v!=vl) + (v!=vr) + (v!=vt) + (v!=vb));
		780	}
		781	}
		782	#define L(x,y) list[ frame->data[0][(x) + (y)*frame->linesize[0]] ]
		783
		784	for (i = 0; i<256; i++) {
		785	int scoretab[256] = {0};
		786	int bestscore = 0;
		787	int bestv = 0;
		788	for (y = 0; y
		789	for (x = 0; x
		790	int v = frame->data[0][x + y*frame->linesize[0]];
		791	int l_m = list[v];
		792	int l_l = x ? L(x-1, y) : 1;
		793	int l_r = x+1
		794	int l_t = y ? L(x, y-1) : 1;
		795	int l_b = y+1
		796	int score;
		797	if (l_m)
		798	continue;
		799	scoretab[v] += l_l + l_r + l_t + l_b;
		800	score = 1024LL*scoretab[v] / counttab[v];
		801	if (score > bestscore) {
		802	bestscore = score;
		803	bestv = v;
		804	}
		805	}
		806	}
		807	if (!bestscore)
		808	break;
		809	list [ bestv ] = 1;
		810	list_inv[ i ] = bestv;
		811	}
		812
		813	count = i - 1;
		814	for (i--; i>=0; i--) {
		815	int v = i*255/count;
		816	AV_WN32(frame->data[1] + 4*list_inv[i], RGBA(v/2,v,v/2,v));
		817	}
		818	}
		819
		820
		821	static int save_subtitle_set(AVCodecContext avctx, AVSubtitle sub, int *got_output)
		822	{
		823	DVBSubContext *ctx = avctx->priv_data;
		824	DVBSubRegionDisplay *display;
		825	DVBSubDisplayDefinition *display_def = ctx->display_definition;
		826	DVBSubRegion *region;
		827	AVSubtitleRect *rect;
		828	DVBSubCLUT *clut;
		829	uint32_t *clut_table;
		830	int i;
		831	int offset_x=0, offset_y=0;
		832	int ret = 0;
		833
		834
		835	if (display_def) {
		836	offset_x = display_def->x;
		837	offset_y = display_def->y;
		838	}
		839
		840	/* Not touching AVSubtitles again*/
		841	if(sub->num_rects) {
		842	avpriv_request_sample(ctx, "Different Version of Segment asked Twice");
		843	return AVERROR_PATCHWELCOME;
		844	}
		845	for (display = ctx->display_list; display; display = display->next) {
		846	region = get_region(ctx, display->region_id);
		847	if (region && region->dirty)
		848	sub->num_rects++;
		849	}
		850
		851	if(ctx->compute_edt == 0) {
		852	sub->end_display_time = ctx->time_out * 1000;
		853	*got_output = 1;
		854	} else if (ctx->prev_start != AV_NOPTS_VALUE) {
		855	sub->end_display_time = av_rescale_q((sub->pts - ctx->prev_start ), AV_TIME_BASE_Q, (AVRational){ 1, 1000 }) - 1;
		856	*got_output = 1;
		857	}
		858	if (sub->num_rects > 0) {
		859
		860	sub->rects = av_mallocz_array(sizeof(*sub->rects), sub->num_rects);
		861	if (!sub->rects) {
		862	ret = AVERROR(ENOMEM);
		863	goto fail;
		864	}
		865
		866	for(i=0; inum_rects; i++)
		867	sub->rects[i] = av_mallocz(sizeof(*sub->rects[i]));
		868
		869	i = 0;
		870
		871	for (display = ctx->display_list; display; display = display->next) {
		872	region = get_region(ctx, display->region_id);
		873
		874	if (!region)
		875	continue;
		876
		877	if (!region->dirty)
		878	continue;
		879
		880	rect = sub->rects[i];
		881	rect->x = display->x_pos + offset_x;
		882	rect->y = display->y_pos + offset_y;
		883	rect->w = region->width;
		884	rect->h = region->height;
		885	rect->nb_colors = (1 << region->depth);
		886	rect->type = SUBTITLE_BITMAP;
		887	rect->pict.linesize[0] = region->width;
		888
		889	clut = get_clut(ctx, region->clut);
		890
		891	if (!clut)
		892	clut = &default_clut;
		893
		894	switch (region->depth) {
		895	case 2:
		896	clut_table = clut->clut4;
		897	break;
		898	case 8:
		899	clut_table = clut->clut256;
		900	break;
		901	case 4:
		902	default:
		903	clut_table = clut->clut16;
		904	break;
		905	}
		906
		907	rect->pict.data[1] = av_mallocz(AVPALETTE_SIZE);
		908	if (!rect->pict.data[1]) {
		909	ret = AVERROR(ENOMEM);
		910	goto fail;
		911	}
		912	memcpy(rect->pict.data[1], clut_table, (1 << region->depth) * sizeof(uint32_t));
		913
		914	rect->pict.data[0] = av_malloc(region->buf_size);
		915	if (!rect->pict.data[0]) {
		916	ret = AVERROR(ENOMEM);
		917	goto fail;
		918	}
		919
		920	memcpy(rect->pict.data[0], region->pbuf, region->buf_size);
		921
		922	if ((clut == &default_clut && ctx->compute_clut == -1) \|\| ctx->compute_clut == 1)
		923	compute_default_clut(&rect->pict, rect->w, rect->h);
		924
		925	i++;
		926	}
		927	}
		928
		929	return 0;
		930	fail:
		931	if (sub->rects) {
		932	for(i=0; inum_rects; i++) {
		933	rect = sub->rects[i];
		934	if (rect) {
		935	av_freep(&rect->pict.data[0]);
		936	av_freep(&rect->pict.data[1]);
		937	}
		938	av_freep(&sub->rects[i]);
		939	}
		940	av_freep(&sub->rects);
		941	}
		942	sub->num_rects = 0;
		943	return ret;
		944	}
		945
		946	static void dvbsub_parse_pixel_data_block(AVCodecContext avctx, DVBSubObjectDisplay display,
		947	const uint8_t *buf, int buf_size, int top_bottom, int non_mod)
		948	{
		949	DVBSubContext *ctx = avctx->priv_data;
		950
		951	DVBSubRegion *region = get_region(ctx, display->region_id);
		952	const uint8_t *buf_end = buf + buf_size;
		953	uint8_t *pbuf;
		954	int x_pos, y_pos;
		955	int i;
		956
		957	uint8_t map2to4[] = { 0x0, 0x7, 0x8, 0xf};
		958	uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
		959	uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
		960	0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
		961	uint8_t *map_table;
		962
		963	#if 0
		964	ff_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
		965	top_bottom ? "bottom" : "top");
		966
		967	for (i = 0; i < buf_size; i++) {
		968	if (i % 16 == 0)
		969	ff_dlog(avctx, "0x%8p: ", buf+i);
		970
		971	ff_dlog(avctx, "%02x ", buf[i]);
		972	if (i % 16 == 15)
		973	ff_dlog(avctx, "\n");
		974	}
		975
		976	if (i % 16)
		977	ff_dlog(avctx, "\n");
		978	#endif
		979
		980	if (!region)
		981	return;
		982
		983	pbuf = region->pbuf;
		984	region->dirty = 1;
		985
		986	x_pos = display->x_pos;
		987	y_pos = display->y_pos;
		988
		989	y_pos += top_bottom;
		990
		991	while (buf < buf_end) {
		992	if ((*buf!=0xf0 && x_pos >= region->width) \|\| y_pos >= region->height) {
		993	av_log(avctx, AV_LOG_ERROR, "Invalid object location! %d-%d %d-%d %02x\n", x_pos, region->width, y_pos, region->height, *buf);
		994	return;
		995	}
		996
		997	switch (*buf++) {
		998	case 0x10:
		999	if (region->depth == 8)
		1000	map_table = map2to8;
		1001	else if (region->depth == 4)
		1002	map_table = map2to4;
		1003	else
		1004	map_table = NULL;
		1005
		1006	x_pos = dvbsub_read_2bit_string(avctx, pbuf + (y_pos * region->width),
		1007	region->width, &buf, buf_end - buf,
		1008	non_mod, map_table, x_pos);
		1009	break;
		1010	case 0x11:
		1011	if (region->depth < 4) {
		1012	av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);
		1013	return;
		1014	}
		1015
		1016	if (region->depth == 8)
		1017	map_table = map4to8;
		1018	else
		1019	map_table = NULL;
		1020
		1021	x_pos = dvbsub_read_4bit_string(avctx, pbuf + (y_pos * region->width),
		1022	region->width, &buf, buf_end - buf,
		1023	non_mod, map_table, x_pos);
		1024	break;
		1025	case 0x12:
		1026	if (region->depth < 8) {
		1027	av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);
		1028	return;
		1029	}
		1030
		1031	x_pos = dvbsub_read_8bit_string(avctx, pbuf + (y_pos * region->width),
		1032	region->width, &buf, buf_end - buf,
		1033	non_mod, NULL, x_pos);
		1034	break;
		1035
		1036	case 0x20:
		1037	map2to4[0] = (*buf) >> 4;
		1038	map2to4[1] = (*buf++) & 0xf;
		1039	map2to4[2] = (*buf) >> 4;
		1040	map2to4[3] = (*buf++) & 0xf;
		1041	break;
		1042	case 0x21:
		1043	for (i = 0; i < 4; i++)
		1044	map2to8[i] = *buf++;
		1045	break;
		1046	case 0x22:
		1047	for (i = 0; i < 16; i++)
		1048	map4to8[i] = *buf++;
		1049	break;
		1050
		1051	case 0xf0:
		1052	x_pos = display->x_pos;
		1053	y_pos += 2;
		1054	break;
		1055	default:
		1056	av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));
		1057	}
		1058	}
		1059
		1060	}
		1061
		1062	static int dvbsub_parse_object_segment(AVCodecContext *avctx,
		1063	const uint8_t *buf, int buf_size)
		1064	{
		1065	DVBSubContext *ctx = avctx->priv_data;
		1066
		1067	const uint8_t *buf_end = buf + buf_size;
		1068	int object_id;
		1069	DVBSubObject *object;
		1070	DVBSubObjectDisplay *display;
		1071	int top_field_len, bottom_field_len;
		1072
		1073	int coding_method, non_modifying_color;
		1074
		1075	object_id = AV_RB16(buf);
		1076	buf += 2;
		1077
		1078	object = get_object(ctx, object_id);
		1079
		1080	if (!object)
		1081	return AVERROR_INVALIDDATA;
		1082
		1083	coding_method = ((*buf) >> 2) & 3;
		1084	non_modifying_color = ((*buf++) >> 1) & 1;
		1085
		1086	if (coding_method == 0) {
		1087	top_field_len = AV_RB16(buf);
		1088	buf += 2;
		1089	bottom_field_len = AV_RB16(buf);
		1090	buf += 2;
		1091
		1092	if (buf + top_field_len + bottom_field_len > buf_end) {
		1093	av_log(avctx, AV_LOG_ERROR, "Field data size %d+%d too large\n", top_field_len, bottom_field_len);
		1094	return AVERROR_INVALIDDATA;
		1095	}
		1096
		1097	for (display = object->display_list; display; display = display->object_list_next) {
		1098	const uint8_t *block = buf;
		1099	int bfl = bottom_field_len;
		1100
		1101	dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,
		1102	non_modifying_color);
		1103
		1104	if (bottom_field_len > 0)
		1105	block = buf + top_field_len;
		1106	else
		1107	bfl = top_field_len;
		1108
		1109	dvbsub_parse_pixel_data_block(avctx, display, block, bfl, 1,
		1110	non_modifying_color);
		1111	}
		1112
		1113	/* } else if (coding_method == 1) {*/
		1114
		1115	} else {
		1116	av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);
		1117	}
		1118
		1119	return 0;
		1120	}
		1121
		1122	static int dvbsub_parse_clut_segment(AVCodecContext *avctx,
		1123	const uint8_t *buf, int buf_size)
		1124	{
		1125	DVBSubContext *ctx = avctx->priv_data;
		1126
		1127	const uint8_t *buf_end = buf + buf_size;
		1128	int i, clut_id;
		1129	int version;
		1130	DVBSubCLUT *clut;
		1131	int entry_id, depth , full_range;
		1132	int y, cr, cb, alpha;
		1133	int r, g, b, r_add, g_add, b_add;
		1134
		1135	ff_dlog(avctx, "DVB clut packet:\n");
		1136
		1137	for (i=0; i < buf_size; i++) {
		1138	ff_dlog(avctx, "%02x ", buf[i]);
		1139	if (i % 16 == 15)
		1140	ff_dlog(avctx, "\n");
		1141	}
		1142
		1143	if (i % 16)
		1144	ff_dlog(avctx, "\n");
		1145
		1146	clut_id = *buf++;
		1147	version = ((*buf)>>4)&15;
		1148	buf += 1;
		1149
		1150	clut = get_clut(ctx, clut_id);
		1151
		1152	if (!clut) {
		1153	clut = av_malloc(sizeof(DVBSubCLUT));
		1154	if (!clut)
		1155	return AVERROR(ENOMEM);
		1156
		1157	memcpy(clut, &default_clut, sizeof(DVBSubCLUT));
		1158
		1159	clut->id = clut_id;
		1160	clut->version = -1;
		1161
		1162	clut->next = ctx->clut_list;
		1163	ctx->clut_list = clut;
		1164	}
		1165
		1166	if (clut->version != version) {
		1167
		1168	clut->version = version;
		1169
		1170	while (buf + 4 < buf_end) {
		1171	entry_id = *buf++;
		1172
		1173	depth = (*buf) & 0xe0;
		1174
		1175	if (depth == 0) {
		1176	av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);
		1177	}
		1178
		1179	full_range = (*buf++) & 1;
		1180
		1181	if (full_range) {
		1182	y = *buf++;
		1183	cr = *buf++;
		1184	cb = *buf++;
		1185	alpha = *buf++;
		1186	} else {
		1187	y = buf[0] & 0xfc;
		1188	cr = (((buf[0] & 3) << 2) \| ((buf[1] >> 6) & 3)) << 4;
		1189	cb = (buf[1] << 2) & 0xf0;
		1190	alpha = (buf[1] << 6) & 0xc0;
		1191
		1192	buf += 2;
		1193	}
		1194
		1195	if (y == 0)
		1196	alpha = 0xff;
		1197
		1198	YUV_TO_RGB1_CCIR(cb, cr);
		1199	YUV_TO_RGB2_CCIR(r, g, b, y);
		1200
		1201	ff_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
		1202	if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {
		1203	ff_dlog(avctx, "More than one bit level marked: %x\n", depth);
		1204	if (avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL)
		1205	return AVERROR_INVALIDDATA;
		1206	}
		1207
		1208	if (depth & 0x80)
		1209	clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
		1210	else if (depth & 0x40)
		1211	clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
		1212	else if (depth & 0x20)
		1213	clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
		1214	}
		1215	}
		1216
		1217	return 0;
		1218	}
		1219
		1220
		1221	static int dvbsub_parse_region_segment(AVCodecContext *avctx,
		1222	const uint8_t *buf, int buf_size)
		1223	{
		1224	DVBSubContext *ctx = avctx->priv_data;
		1225
		1226	const uint8_t *buf_end = buf + buf_size;
		1227	int region_id, object_id;
		1228	int av_unused version;
		1229	DVBSubRegion *region;
		1230	DVBSubObject *object;
		1231	DVBSubObjectDisplay *display;
		1232	int fill;
		1233
		1234	if (buf_size < 10)
		1235	return AVERROR_INVALIDDATA;
		1236
		1237	region_id = *buf++;
		1238
		1239	region = get_region(ctx, region_id);
		1240
		1241	if (!region) {
		1242	region = av_mallocz(sizeof(DVBSubRegion));
		1243	if (!region)
		1244	return AVERROR(ENOMEM);
		1245
		1246	region->id = region_id;
		1247	region->version = -1;
		1248
		1249	region->next = ctx->region_list;
		1250	ctx->region_list = region;
		1251	}
		1252
		1253	version = ((*buf)>>4) & 15;
		1254	fill = ((*buf++) >> 3) & 1;
		1255
		1256	region->width = AV_RB16(buf);
		1257	buf += 2;
		1258	region->height = AV_RB16(buf);
		1259	buf += 2;
		1260
		1261	if (region->width * region->height != region->buf_size) {
		1262	av_free(region->pbuf);
		1263
		1264	region->buf_size = region->width * region->height;
		1265
		1266	region->pbuf = av_malloc(region->buf_size);
		1267	if (!region->pbuf) {
		1268	region->buf_size =
		1269	region->width =
		1270	region->height = 0;
		1271	return AVERROR(ENOMEM);
		1272	}
		1273
		1274	fill = 1;
		1275	region->dirty = 0;
		1276	}
		1277
		1278	region->depth = 1 << (((*buf++) >> 2) & 7);
		1279	if(region->depth<2 \|\| region->depth>8){
		1280	av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);
		1281	region->depth= 4;
		1282	}
		1283	region->clut = *buf++;
		1284
		1285	if (region->depth == 8) {
		1286	region->bgcolor = *buf++;
		1287	buf += 1;
		1288	} else {
		1289	buf += 1;
		1290
		1291	if (region->depth == 4)
		1292	region->bgcolor = (((*buf++) >> 4) & 15);
		1293	else
		1294	region->bgcolor = (((*buf++) >> 2) & 3);
		1295	}
		1296
		1297	ff_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);
		1298
		1299	if (fill) {
		1300	memset(region->pbuf, region->bgcolor, region->buf_size);
		1301	ff_dlog(avctx, "Fill region (%d)\n", region->bgcolor);
		1302	}
		1303
		1304	delete_region_display_list(ctx, region);
		1305
		1306	while (buf + 5 < buf_end) {
		1307	object_id = AV_RB16(buf);
		1308	buf += 2;
		1309
		1310	object = get_object(ctx, object_id);
		1311
		1312	if (!object) {
		1313	object = av_mallocz(sizeof(DVBSubObject));
		1314	if (!object)
		1315	return AVERROR(ENOMEM);
		1316
		1317	object->id = object_id;
		1318	object->next = ctx->object_list;
		1319	ctx->object_list = object;
		1320	}
		1321
		1322	object->type = (*buf) >> 6;
		1323
		1324	display = av_mallocz(sizeof(DVBSubObjectDisplay));
		1325	if (!display)
		1326	return AVERROR(ENOMEM);
		1327
		1328	display->object_id = object_id;
		1329	display->region_id = region_id;
		1330
		1331	display->x_pos = AV_RB16(buf) & 0xfff;
		1332	buf += 2;
		1333	display->y_pos = AV_RB16(buf) & 0xfff;
		1334	buf += 2;
		1335
		1336	if ((object->type == 1 \|\| object->type == 2) && buf+1 < buf_end) {
		1337	display->fgcolor = *buf++;
		1338	display->bgcolor = *buf++;
		1339	}
		1340
		1341	display->region_list_next = region->display_list;
		1342	region->display_list = display;
		1343
		1344	display->object_list_next = object->display_list;
		1345	object->display_list = display;
		1346	}
		1347
		1348	return 0;
		1349	}
		1350
		1351	static int dvbsub_parse_page_segment(AVCodecContext *avctx,
		1352	const uint8_t buf, int buf_size, AVSubtitle sub, int *got_output)
		1353	{
		1354	DVBSubContext *ctx = avctx->priv_data;
		1355	DVBSubRegionDisplay *display;
		1356	DVBSubRegionDisplay tmp_display_list, *tmp_ptr;
		1357
		1358	const uint8_t *buf_end = buf + buf_size;
		1359	int region_id;
		1360	int page_state;
		1361	int timeout;
		1362	int version;
		1363
		1364	if (buf_size < 1)
		1365	return AVERROR_INVALIDDATA;
		1366
		1367	timeout = *buf++;
		1368	version = ((*buf)>>4) & 15;
		1369	page_state = ((*buf++) >> 2) & 3;
		1370
		1371	if (ctx->version == version) {
		1372	return 0;
		1373	}
		1374
		1375	ctx->time_out = timeout;
		1376	ctx->version = version;
		1377
		1378	ff_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);
		1379
		1380	if(ctx->compute_edt == 1)
		1381	save_subtitle_set(avctx, sub, got_output);
		1382
		1383	if (page_state == 1 \|\| page_state == 2) {
		1384	delete_regions(ctx);
		1385	delete_objects(ctx);
		1386	delete_cluts(ctx);
		1387	}
		1388
		1389	tmp_display_list = ctx->display_list;
		1390	ctx->display_list = NULL;
		1391
		1392	while (buf + 5 < buf_end) {
		1393	region_id = *buf++;
		1394	buf += 1;
		1395
		1396	display = tmp_display_list;
		1397	tmp_ptr = &tmp_display_list;
		1398
		1399	while (display && display->region_id != region_id) {
		1400	tmp_ptr = &display->next;
		1401	display = display->next;
		1402	}
		1403
		1404	if (!display) {
		1405	display = av_mallocz(sizeof(DVBSubRegionDisplay));
		1406	if (!display)
		1407	return AVERROR(ENOMEM);
		1408	}
		1409
		1410	display->region_id = region_id;
		1411
		1412	display->x_pos = AV_RB16(buf);
		1413	buf += 2;
		1414	display->y_pos = AV_RB16(buf);
		1415	buf += 2;
		1416
		1417	*tmp_ptr = display->next;
		1418
		1419	display->next = ctx->display_list;
		1420	ctx->display_list = display;
		1421
		1422	ff_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
		1423	}
		1424
		1425	while (tmp_display_list) {
		1426	display = tmp_display_list;
		1427
		1428	tmp_display_list = display->next;
		1429
		1430	av_freep(&display);
		1431	}
		1432
		1433	return 0;
		1434	}
		1435
		1436
		1437	#ifdef DEBUG
		1438	static void save_display_set(DVBSubContext *ctx)
		1439	{
		1440	DVBSubRegion *region;
		1441	DVBSubRegionDisplay *display;
		1442	DVBSubCLUT *clut;
		1443	uint32_t *clut_table;
		1444	int x_pos, y_pos, width, height;
		1445	int x, y, y_off, x_off;
		1446	uint32_t *pbuf;
		1447	char filename[32];
		1448	static int fileno_index = 0;
		1449
		1450	x_pos = -1;
		1451	y_pos = -1;
		1452	width = 0;
		1453	height = 0;
		1454
		1455	for (display = ctx->display_list; display; display = display->next) {
		1456	region = get_region(ctx, display->region_id);
		1457
		1458	if (!region)
		1459	return;
		1460
		1461	if (x_pos == -1) {
		1462	x_pos = display->x_pos;
		1463	y_pos = display->y_pos;
		1464	width = region->width;
		1465	height = region->height;
		1466	} else {
		1467	if (display->x_pos < x_pos) {
		1468	width += (x_pos - display->x_pos);
		1469	x_pos = display->x_pos;
		1470	}
		1471
		1472	if (display->y_pos < y_pos) {
		1473	height += (y_pos - display->y_pos);
		1474	y_pos = display->y_pos;
		1475	}
		1476
		1477	if (display->x_pos + region->width > x_pos + width) {
		1478	width = display->x_pos + region->width - x_pos;
		1479	}
		1480
		1481	if (display->y_pos + region->height > y_pos + height) {
		1482	height = display->y_pos + region->height - y_pos;
		1483	}
		1484	}
		1485	}
		1486
		1487	if (x_pos >= 0) {
		1488
		1489	pbuf = av_malloc(width * height * 4);
		1490	if (!pbuf)
		1491	return;
		1492
		1493	for (display = ctx->display_list; display; display = display->next) {
		1494	region = get_region(ctx, display->region_id);
		1495
		1496	if (!region)
		1497	return;
		1498
		1499	x_off = display->x_pos - x_pos;
		1500	y_off = display->y_pos - y_pos;
		1501
		1502	clut = get_clut(ctx, region->clut);
		1503
		1504	if (!clut)
		1505	clut = &default_clut;
		1506
		1507	switch (region->depth) {
		1508	case 2:
		1509	clut_table = clut->clut4;
		1510	break;
		1511	case 8:
		1512	clut_table = clut->clut256;
		1513	break;
		1514	case 4:
		1515	default:
		1516	clut_table = clut->clut16;
		1517	break;
		1518	}
		1519
		1520	for (y = 0; y < region->height; y++) {
		1521	for (x = 0; x < region->width; x++) {
		1522	pbuf[((y + y_off) * width) + x_off + x] =
		1523	clut_table[region->pbuf[y * region->width + x]];
		1524	}
		1525	}
		1526
		1527	}
		1528
		1529	snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
		1530
		1531	png_save2(filename, pbuf, width, height);
		1532
		1533	av_freep(&pbuf);
		1534	}
		1535
		1536	fileno_index++;
		1537	}
		1538	#endif
		1539
		1540	static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx,
		1541	const uint8_t *buf,
		1542	int buf_size)
		1543	{
		1544	DVBSubContext *ctx = avctx->priv_data;
		1545	DVBSubDisplayDefinition *display_def = ctx->display_definition;
		1546	int dds_version, info_byte;
		1547
		1548	if (buf_size < 5)
		1549	return AVERROR_INVALIDDATA;
		1550
		1551	info_byte = bytestream_get_byte(&buf);
		1552	dds_version = info_byte >> 4;
		1553	if (display_def && display_def->version == dds_version)
		1554	return 0; // already have this display definition version
		1555
		1556	if (!display_def) {
		1557	display_def = av_mallocz(sizeof(*display_def));
		1558	if (!display_def)
		1559	return AVERROR(ENOMEM);
		1560	ctx->display_definition = display_def;
		1561	}
		1562
		1563	display_def->version = dds_version;
		1564	display_def->x = 0;
		1565	display_def->y = 0;
		1566	display_def->width = bytestream_get_be16(&buf) + 1;
		1567	display_def->height = bytestream_get_be16(&buf) + 1;
		1568	if (!avctx->width \|\| !avctx->height) {
		1569	avctx->width = display_def->width;
		1570	avctx->height = display_def->height;
		1571	}
		1572
		1573	if (info_byte & 1<<3) { // display_window_flag
		1574	if (buf_size < 13)
		1575	return AVERROR_INVALIDDATA;
		1576
		1577	display_def->x = bytestream_get_be16(&buf);
		1578	display_def->width = bytestream_get_be16(&buf) - display_def->x + 1;
		1579	display_def->y = bytestream_get_be16(&buf);
		1580	display_def->height = bytestream_get_be16(&buf) - display_def->y + 1;
		1581	}
		1582
		1583	return 0;
		1584	}
		1585
		1586	static int dvbsub_display_end_segment(AVCodecContext avctx, const uint8_t buf,
		1587	int buf_size, AVSubtitle sub,int got_output)
		1588	{
		1589	DVBSubContext *ctx = avctx->priv_data;
		1590
		1591	if(ctx->compute_edt == 0)
		1592	save_subtitle_set(avctx, sub, got_output);
		1593	#ifdef DEBUG
		1594	save_display_set(ctx);
		1595	#endif
		1596	return 0;
		1597	}
		1598
		1599	static int dvbsub_decode(AVCodecContext *avctx,
		1600	void data, int data_size,
		1601	AVPacket *avpkt)
		1602	{
		1603	const uint8_t *buf = avpkt->data;
		1604	int buf_size = avpkt->size;
		1605	DVBSubContext *ctx = avctx->priv_data;
		1606	AVSubtitle *sub = data;
		1607	const uint8_t p, p_end;
		1608	int segment_type;
		1609	int page_id;
		1610	int segment_length;
		1611	int i;
		1612	int ret = 0;
		1613	int got_segment = 0;
		1614	int got_dds = 0;
		1615
		1616	ff_dlog(avctx, "DVB sub packet:\n");
		1617
		1618	for (i=0; i < buf_size; i++) {
		1619	ff_dlog(avctx, "%02x ", buf[i]);
		1620	if (i % 16 == 15)
		1621	ff_dlog(avctx, "\n");
		1622	}
		1623
		1624	if (i % 16)
		1625	ff_dlog(avctx, "\n");
		1626
		1627	if (buf_size <= 6 \|\| *buf != 0x0f) {
		1628	ff_dlog(avctx, "incomplete or broken packet");
		1629	return AVERROR_INVALIDDATA;
		1630	}
		1631
		1632	p = buf;
		1633	p_end = buf + buf_size;
		1634
		1635	while (p_end - p >= 6 && *p == 0x0f) {
		1636	p += 1;
		1637	segment_type = *p++;
		1638	page_id = AV_RB16(p);
		1639	p += 2;
		1640	segment_length = AV_RB16(p);
		1641	p += 2;
		1642
		1643	if (avctx->debug & FF_DEBUG_STARTCODE) {
		1644	av_log(avctx, AV_LOG_DEBUG, "segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length);
		1645	}
		1646
		1647	if (p_end - p < segment_length) {
		1648	ff_dlog(avctx, "incomplete or broken packet");
		1649	ret = -1;
		1650	goto end;
		1651	}
		1652
		1653	if (page_id == ctx->composition_id \|\| page_id == ctx->ancillary_id \|\|
		1654	ctx->composition_id == -1 \|\| ctx->ancillary_id == -1) {
		1655	int ret = 0;
		1656	switch (segment_type) {
		1657	case DVBSUB_PAGE_SEGMENT:
		1658	ret = dvbsub_parse_page_segment(avctx, p, segment_length, sub, data_size);
		1659	got_segment \|= 1;
		1660	break;
		1661	case DVBSUB_REGION_SEGMENT:
		1662	ret = dvbsub_parse_region_segment(avctx, p, segment_length);
		1663	got_segment \|= 2;
		1664	break;
		1665	case DVBSUB_CLUT_SEGMENT:
		1666	ret = dvbsub_parse_clut_segment(avctx, p, segment_length);
		1667	if (ret < 0) goto end;
		1668	got_segment \|= 4;
		1669	break;
		1670	case DVBSUB_OBJECT_SEGMENT:
		1671	ret = dvbsub_parse_object_segment(avctx, p, segment_length);
		1672	got_segment \|= 8;
		1673	break;
		1674	case DVBSUB_DISPLAYDEFINITION_SEGMENT:
		1675	ret = dvbsub_parse_display_definition_segment(avctx, p,
		1676	segment_length);
		1677	got_dds = 1;
		1678	break;
		1679	case DVBSUB_DISPLAY_SEGMENT:
		1680	ret = dvbsub_display_end_segment(avctx, p, segment_length, sub, data_size);
		1681	if (got_segment == 15 && !got_dds && !avctx->width && !avctx->height) {
		1682	// Default from ETSI EN 300 743 V1.3.1 (7.2.1)
		1683	avctx->width = 720;
		1684	avctx->height = 576;
		1685	}
		1686	got_segment \|= 16;
		1687	break;
		1688	default:
		1689	ff_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",
		1690	segment_type, page_id, segment_length);
		1691	break;
		1692	}
		1693	if (ret < 0)
		1694	goto end;
		1695	}
		1696
		1697	p += segment_length;
		1698	}
		1699	// Some streams do not send a display segment but if we have all the other
		1700	// segments then we need no further data.
		1701	if (got_segment == 15) {
		1702	av_log(avctx, AV_LOG_DEBUG, "Missing display_end_segment, emulating\n");
		1703	dvbsub_display_end_segment(avctx, p, 0, sub, data_size);
		1704	}
		1705
		1706	end:
		1707	if(ret < 0) {
		1708	*data_size = 0;
		1709	avsubtitle_free(sub);
		1710	return ret;
		1711	} else {
		1712	if(ctx->compute_edt == 1 )
		1713	FFSWAP(int64_t, ctx->prev_start, sub->pts);
		1714	}
		1715
		1716	return p - buf;
		1717	}
		1718
		1719	#define DS AV_OPT_FLAG_DECODING_PARAM \| AV_OPT_FLAG_SUBTITLE_PARAM
		1720	static const AVOption options[] = {
		1721	{"compute_edt", "compute end of time using pts or timeout", offsetof(DVBSubContext, compute_edt), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DS},
		1722	{"compute_clut", "compute clut when not available(-1) or always(1) or never(0)", offsetof(DVBSubContext, compute_clut), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, DS},
		1723	{"dvb_substream", "", offsetof(DVBSubContext, substream), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, DS},
		1724	{NULL}
		1725	};
		1726	static const AVClass dvbsubdec_class = {
		1727	.class_name = "DVB Sub Decoder",
		1728	.item_name = av_default_item_name,
		1729	.option = options,
		1730	.version = LIBAVUTIL_VERSION_INT,
		1731	};
		1732
		1733	AVCodec ff_dvbsub_decoder = {
		1734	.name = "dvbsub",
		1735	.long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),
		1736	.type = AVMEDIA_TYPE_SUBTITLE,
		1737	.id = AV_CODEC_ID_DVB_SUBTITLE,
		1738	.priv_data_size = sizeof(DVBSubContext),
		1739	.init = dvbsub_init_decoder,
		1740	.close = dvbsub_close_decoder,
		1741	.decode = dvbsub_decode,
		1742	.priv_class = &dvbsubdec_class,
		1743	};

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavcodec/dvbsubdec.c – Rev 6147