30 #define DVBSUB_PAGE_SEGMENT 0x10 31 #define DVBSUB_REGION_SEGMENT 0x11 32 #define DVBSUB_CLUT_SEGMENT 0x12 33 #define DVBSUB_OBJECT_SEGMENT 0x13 34 #define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14 35 #define DVBSUB_DISPLAY_SEGMENT 0x80 37 #define cm (ff_crop_tab + MAX_NEG_CROP) 39 #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b)) 130 int clut_count2[257][256];
146 while (ptr && ptr->
id != object_id) {
157 while (ptr && ptr->
id != clut_id) {
168 while (ptr && ptr->
id != region_id) {
186 obj_disp_ptr = &
object->display_list;
187 obj_disp = *obj_disp_ptr;
189 while (obj_disp && obj_disp != display) {
191 obj_disp = *obj_disp_ptr;
201 while (obj2 !=
object) {
203 obj2_ptr = &obj2->
next;
207 *obj2_ptr = obj2->
next;
259 int i,
r,
g,
b,
a = 0;
283 default_clut.
id = -1;
286 default_clut.
clut4[0] =
RGBA( 0, 0, 0, 0);
287 default_clut.
clut4[1] =
RGBA(255, 255, 255, 255);
288 default_clut.
clut4[2] =
RGBA( 0, 0, 0, 255);
289 default_clut.
clut4[3] =
RGBA(127, 127, 127, 255);
292 for (i = 1; i < 16; i++) {
294 r = (i & 1) ? 255 : 0;
295 g = (i & 2) ? 255 : 0;
296 b = (i & 4) ? 255 : 0;
298 r = (i & 1) ? 127 : 0;
299 g = (i & 2) ? 127 : 0;
300 b = (i & 4) ? 127 : 0;
306 for (i = 1; i < 256; i++) {
308 r = (i & 1) ? 255 : 0;
309 g = (i & 2) ? 255 : 0;
310 b = (i & 4) ? 255 : 0;
315 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
316 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
317 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
321 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
322 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
323 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
327 r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
328 g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
329 b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
333 r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
334 g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
335 b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
370 uint8_t *destbuf,
int dbuf_len,
371 const uint8_t **srcbuf,
int buf_size,
372 int non_mod,
uint8_t *map_table,
int x_pos)
378 int pixels_read = x_pos;
384 while (
get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
388 if (non_mod != 1 || bits != 1) {
390 *destbuf++ = map_table[
bits];
401 if (non_mod == 1 && bits == 1)
402 pixels_read += run_length;
405 bits = map_table[
bits];
406 while (run_length-- > 0 && pixels_read < dbuf_len) {
419 if (non_mod == 1 && bits == 1)
420 pixels_read += run_length;
423 bits = map_table[
bits];
424 while (run_length-- > 0 && pixels_read < dbuf_len) {
429 }
else if (bits == 3) {
433 if (non_mod == 1 && bits == 1)
434 pixels_read += run_length;
437 bits = map_table[
bits];
438 while (run_length-- > 0 && pixels_read < dbuf_len) {
443 }
else if (bits == 1) {
449 while (run_length-- > 0 && pixels_read < dbuf_len) {
478 const uint8_t **srcbuf,
int buf_size,
479 int non_mod,
uint8_t *map_table,
int x_pos)
485 int pixels_read = x_pos;
491 while (
get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {
495 if (non_mod != 1 || bits != 1) {
497 *destbuf++ = map_table[
bits];
507 if (run_length == 0) {
519 while (run_length-- > 0 && pixels_read < dbuf_len) {
529 if (non_mod == 1 && bits == 1)
530 pixels_read += run_length;
533 bits = map_table[
bits];
534 while (run_length-- > 0 && pixels_read < dbuf_len) {
545 if (non_mod == 1 && bits == 1)
546 pixels_read += run_length;
549 bits = map_table[
bits];
550 while (run_length-- > 0 && pixels_read < dbuf_len) {
555 }
else if (bits == 3) {
559 if (non_mod == 1 && bits == 1)
560 pixels_read += run_length;
563 bits = map_table[
bits];
564 while (run_length-- > 0 && pixels_read < dbuf_len) {
569 }
else if (bits == 1) {
575 while (run_length-- > 0 && pixels_read < dbuf_len) {
601 uint8_t *destbuf,
int dbuf_len,
602 const uint8_t **srcbuf,
int buf_size,
603 int non_mod,
uint8_t *map_table,
int x_pos)
605 const uint8_t *sbuf_end = (*srcbuf) + buf_size;
608 int pixels_read = x_pos;
612 while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {
616 if (non_mod != 1 || bits != 1) {
618 *destbuf++ = map_table[
bits];
625 run_length = bits & 0x7f;
626 if ((bits & 0x80) == 0) {
627 if (run_length == 0) {
635 if (non_mod == 1 && bits == 1)
636 pixels_read += run_length;
639 bits = map_table[
bits];
640 while (run_length-- > 0 && pixels_read < dbuf_len) {
658 int counttab[256] = {0};
665 #define V(x,y) rect->data[0][(x) + (y)*stride] 666 for (y = 0; y<
h; y++) {
667 for (x = 0; x<
w; x++) {
669 int vl = x ?
V(x-1,y) + 1 : 0;
670 int vr = x+1<w ?
V(x+1,y) + 1 : 0;
671 int vt = y ?
V(x,y-1) + 1 : 0;
672 int vb = y+1<h ?
V(x,y+1) + 1 : 0;
673 counttab[v-1] += !!((v!=vl) + (v!=vr) + (v!=vt) + (v!=vb));
674 counttab2[vl][v-1] ++;
675 counttab2[vr][v-1] ++;
676 counttab2[vt][v-1] ++;
677 counttab2[vb][v-1] ++;
680 #define L(x,y) list[d[(x) + (y)*stride]] 682 for (i = 0; i<256; i++) {
683 counttab2[i+1][
i] = 0;
685 for (i = 0; i<256; i++) {
689 for (x = 0; x < 256; x++) {
693 scorev += counttab2[0][x];
694 for (y = 0; y < 256; y++) {
695 scorev += list[y] * counttab2[y+1][x];
699 int score = 1024LL*scorev / counttab[x];
700 if (score > bestscore) {
709 list_inv[
i ] = bestv;
712 count =
FFMAX(i - 1, 1);
713 for (i--; i >= 0; i--) {
714 int v = i * 255 /
count;
728 uint32_t *clut_table;
730 int offset_x=0, offset_y=0;
735 offset_x = display_def->
x;
736 offset_y = display_def->
y;
746 if (region && region->
dirty)
767 if (!sub->
rects[i]) {
785 rect->
x = display->
x_pos + offset_x;
786 rect->
y = display->
y_pos + offset_y;
798 switch (region->
depth) {
800 clut_table = clut->
clut4;
807 clut_table = clut->
clut16;
812 if (!rect->
data[1]) {
816 memcpy(rect->
data[1], clut_table, (1 << region->
depth) *
sizeof(*clut_table));
819 if (!rect->
data[0]) {
839 for (j = 0; j < 4; j++) {
869 const uint8_t *buf,
int buf_size,
int top_bottom,
int non_mod)
874 const uint8_t *buf_end = buf + buf_size;
879 uint8_t map2to4[] = { 0x0, 0x7, 0x8, 0xf};
880 uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};
881 uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
882 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
886 ff_dlog(avctx,
"DVB pixel block size %d, %s field:\n", buf_size,
887 top_bottom ?
"bottom" :
"top");
889 for (i = 0; i < buf_size; i++) {
891 ff_dlog(avctx,
"0x%8p: ", buf+i);
893 ff_dlog(avctx,
"%02x ", buf[i]);
908 x_pos = display->
x_pos;
909 y_pos = display->
y_pos;
913 while (buf < buf_end) {
914 if ((*buf!=0xf0 && x_pos >= region->
width) || y_pos >= region->
height) {
921 if (region->
depth == 8)
923 else if (region->
depth == 4)
929 region->
width, &buf, buf_end - buf,
930 non_mod, map_table, x_pos);
933 if (region->
depth < 4) {
938 if (region->
depth == 8)
944 region->
width, &buf, buf_end - buf,
945 non_mod, map_table, x_pos);
948 if (region->
depth < 8) {
954 region->
width, &buf, buf_end - buf,
955 non_mod,
NULL, x_pos);
959 map2to4[0] = (*buf) >> 4;
960 map2to4[1] = (*buf++) & 0
xf;
961 map2to4[2] = (*buf) >> 4;
962 map2to4[3] = (*buf++) & 0
xf;
965 for (i = 0; i < 4; i++)
969 for (i = 0; i < 16; i++)
974 x_pos = display->
x_pos;
986 const uint8_t *buf,
int buf_size)
990 const uint8_t *buf_end = buf + buf_size;
994 int top_field_len, bottom_field_len;
996 int coding_method, non_modifying_color;
1006 coding_method = ((*buf) >> 2) & 3;
1007 non_modifying_color = ((*buf++) >> 1) & 1;
1009 if (coding_method == 0) {
1012 bottom_field_len =
AV_RB16(buf);
1015 if (buf + top_field_len + bottom_field_len > buf_end) {
1016 av_log(avctx,
AV_LOG_ERROR,
"Field data size %d+%d too large\n", top_field_len, bottom_field_len);
1022 int bfl = bottom_field_len;
1025 non_modifying_color);
1027 if (bottom_field_len > 0)
1028 block = buf + top_field_len;
1030 bfl = top_field_len;
1033 non_modifying_color);
1035 }
else if (coding_method == 1) {
1038 }
else if (coding_method == 2) {
1050 const uint8_t *buf,
int buf_size)
1054 const uint8_t *buf_end = buf + buf_size;
1060 int r,
g,
b, r_add, g_add, b_add;
1062 ff_dlog(avctx,
"DVB clut packet:\n");
1064 for (i=0; i < buf_size; i++) {
1065 ff_dlog(avctx,
"%02x ", buf[i]);
1074 version = ((*buf)>>4)&15;
1084 memcpy(clut, &default_clut,
sizeof(*clut));
1093 if (clut->
version != version) {
1097 while (buf + 4 < buf_end) {
1100 depth = (*buf) & 0xe0;
1106 full_range = (*buf++) & 1;
1115 cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
1116 cb = (buf[1] << 2) & 0xf0;
1117 alpha = (buf[1] << 6) & 0xc0;
1128 ff_dlog(avctx,
"clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);
1129 if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {
1130 ff_dlog(avctx,
"More than one bit level marked: %x\n", depth);
1135 if (depth & 0x80 && entry_id < 4)
1136 clut->
clut4[entry_id] =
RGBA(r,g,b,255 - alpha);
1137 else if (depth & 0x40 && entry_id < 16)
1138 clut->
clut16[entry_id] =
RGBA(r,g,b,255 - alpha);
1139 else if (depth & 0x20)
1140 clut->
clut256[entry_id] =
RGBA(r,g,b,255 - alpha);
1149 const uint8_t *buf,
int buf_size)
1153 const uint8_t *buf_end = buf + buf_size;
1154 int region_id, object_id;
1174 region->
id = region_id;
1181 version = ((*buf)>>4) & 15;
1182 fill = ((*buf++) >> 3) & 1;
1190 if (ret >= 0 && region->
width * region->
height * 2 > 320 * 1024 * 8) {
1205 if (!region->
pbuf) {
1216 region->
depth = 1 << (((*buf++) >> 2) & 7);
1217 if (region->
depth < 2 || region->
depth > 8) {
1221 region->
clut = *buf++;
1223 if (region->
depth == 8) {
1229 if (region->
depth == 4)
1230 region->
bgcolor = (((*buf++) >> 4) & 15);
1232 region->
bgcolor = (((*buf++) >> 2) & 3);
1244 while (buf + 5 < buf_end) {
1255 object->id = object_id;
1260 object->
type = (*buf) >> 6;
1281 if ((object->
type == 1 || object->
type == 2) && buf+1 < buf_end) {
1290 object->display_list = display;
1303 const uint8_t *buf_end = buf + buf_size;
1313 version = ((*buf)>>4) & 15;
1314 page_state = ((*buf++) >> 2) & 3;
1316 if (ctx->
version == version) {
1323 ff_dlog(avctx,
"Page time out %ds, state %d\n", ctx->
time_out, page_state);
1328 if (page_state == 1 || page_state == 2) {
1337 while (buf + 5 < buf_end) {
1342 while (display && display->
region_id != region_id) {
1343 display = display->
next;
1350 display = tmp_display_list;
1351 tmp_ptr = &tmp_display_list;
1353 while (display && display->
region_id != region_id) {
1354 tmp_ptr = &display->
next;
1355 display = display->
next;
1371 *tmp_ptr = display->
next;
1376 ff_dlog(avctx,
"Region %d, (%d,%d)\n", region_id, display->
x_pos, display->
y_pos);
1379 while (tmp_display_list) {
1380 display = tmp_display_list;
1382 tmp_display_list = display->
next;
1392 static void png_save(
DVBSubContext *
ctx,
const char *filename, uint32_t *bitmap,
int w,
int h)
1396 char fname[40], fname2[40];
1399 snprintf(fname,
sizeof(fname),
"%s.ppm", filename);
1401 f = fopen(fname,
"w");
1410 for(y = 0; y <
h; y++) {
1411 for(x = 0; x <
w; x++) {
1412 v = bitmap[y * w + x];
1413 putc((v >> 16) & 0xff, f);
1414 putc((v >> 8) & 0xff, f);
1415 putc((v >> 0) & 0xff, f);
1421 snprintf(fname2,
sizeof(fname2),
"%s-a.pgm", filename);
1423 f = fopen(fname2,
"w");
1432 for(y = 0; y <
h; y++) {
1433 for(x = 0; x <
w; x++) {
1434 v = bitmap[y * w + x];
1435 putc((v >> 24) & 0xff, f);
1440 snprintf(command,
sizeof(command),
"pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
1441 if (
system(command) != 0) {
1446 snprintf(command,
sizeof(command),
"rm %s %s", fname, fname2);
1447 if (
system(command) != 0) {
1458 uint32_t *clut_table;
1460 int x, y, y_off, x_off;
1463 static int fileno_index = 0;
1477 x_pos = display->
x_pos;
1478 y_pos = display->
y_pos;
1479 width = region->
width;
1482 if (display->
x_pos < x_pos) {
1483 width += (x_pos - display->
x_pos);
1484 x_pos = display->
x_pos;
1487 if (display->
y_pos < y_pos) {
1488 height += (y_pos - display->
y_pos);
1489 y_pos = display->
y_pos;
1492 if (display->
x_pos + region->
width > x_pos + width) {
1493 width = display->
x_pos + region->
width - x_pos;
1496 if (display->
y_pos + region->
height > y_pos + height) {
1514 x_off = display->
x_pos - x_pos;
1515 y_off = display->
y_pos - y_pos;
1522 switch (region->
depth) {
1524 clut_table = clut->
clut4;
1531 clut_table = clut->
clut16;
1535 for (y = 0; y < region->
height; y++) {
1536 for (x = 0; x < region->
width; x++) {
1537 pbuf[((y + y_off) * width) + x_off + x] =
1538 clut_table[region->
pbuf[y * region->
width + x]];
1544 snprintf(filename,
sizeof(filename),
"dvbs.%d", fileno_index);
1546 png_save(ctx, filename, pbuf, width, height);
1562 int dds_version, info_byte;
1567 info_byte = bytestream_get_byte(&buf);
1568 dds_version = info_byte >> 4;
1569 if (display_def && display_def->
version == dds_version)
1573 display_def =
av_mallocz(
sizeof(*display_def));
1579 display_def->
version = dds_version;
1582 display_def->
width = bytestream_get_be16(&buf) + 1;
1583 display_def->
height = bytestream_get_be16(&buf) + 1;
1590 if (info_byte & 1<<3) {
1594 display_def->
x = bytestream_get_be16(&buf);
1595 display_def->
width = bytestream_get_be16(&buf) - display_def->
x + 1;
1596 display_def->
y = bytestream_get_be16(&buf);
1597 display_def->
height = bytestream_get_be16(&buf) - display_def->
y + 1;
1611 save_display_set(ctx);
1617 void *
data,
int *got_sub_ptr,
1621 int buf_size = avpkt->
size;
1630 int got_segment = 0;
1633 ff_dlog(avctx,
"DVB sub packet:\n");
1635 for (i=0; i < buf_size; i++) {
1636 ff_dlog(avctx,
"%02x ", buf[i]);
1644 if (buf_size <= 6 || *buf != 0x0f) {
1645 ff_dlog(avctx,
"incomplete or broken packet");
1650 p_end = buf + buf_size;
1652 while (p_end - p >= 6 && *p == 0x0f) {
1654 segment_type = *p++;
1661 av_log(avctx,
AV_LOG_DEBUG,
"segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length);
1664 if (p_end - p < segment_length) {
1665 ff_dlog(avctx,
"incomplete or broken packet");
1673 switch (segment_type) {
1684 if (ret < 0)
goto end;
1698 if (got_segment == 15 && !got_dds && !avctx->
width && !avctx->
height) {
1706 ff_dlog(avctx,
"Subtitling segment type 0x%x, page id %d, length %d\n",
1707 segment_type, page_id, segment_length);
1714 p += segment_length;
1718 if (got_segment == 15) {
1736 #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM 1737 #define OFFSET(x) offsetof(DVBSubContext, x) 1739 {
"compute_edt",
"compute end of time using pts or timeout",
OFFSET(compute_edt),
AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
DS},
1740 {
"compute_clut",
"compute clut when not available(-1) or always(1) or never(0)",
OFFSET(compute_clut),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
DS},
1760 .priv_class = &dvbsubdec_class,
static DVBSubCLUT * get_clut(DVBSubContext *ctx, int clut_id)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int dvbsub_read_8bit_string(AVCodecContext *avctx, uint8_t *destbuf, int dbuf_len, const uint8_t **srcbuf, int buf_size, int non_mod, uint8_t *map_table, int x_pos)
static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display, const uint8_t *buf, int buf_size, int top_bottom, int non_mod)
int x
top left corner of pict, undefined when pict is not set
static DVBSubRegion * get_region(DVBSubContext *ctx, int region_id)
ptrdiff_t const GLvoid * data
DVBSubRegionDisplay * display_list
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
static av_cold int init(AVCodecContext *avctx)
#define avpriv_request_sample(...)
int nb_colors
number of colors in pict, undefined when pict is not set
const char * av_default_item_name(void *ptr)
Return the context name.
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static int dvbsub_parse_page_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
attribute_deprecated AVPicture pict
static int dvbsub_decode(AVCodecContext *avctx, void *data, int *got_sub_ptr, AVPacket *avpkt)
int w
width of pict, undefined when pict is not set
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static double cb(void *priv, double x, double y)
The exact code depends on how similar the blocks are and how related they are to the block
static int dvbsub_read_4bit_string(AVCodecContext *avctx, uint8_t *destbuf, int dbuf_len, const uint8_t **srcbuf, int buf_size, int non_mod, uint8_t *map_table, int x_pos)
static void delete_cluts(DVBSubContext *ctx)
8 bits with AV_PIX_FMT_RGB32 palette
attribute_deprecated int linesize[AV_NUM_DATA_POINTERS]
number of bytes per line
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
static const AVClass dvbsubdec_class
static int get_bits_count(const GetBitContext *s)
bitstream reader API header.
int h
height of pict, undefined when pict is not set
DVBSubRegion * region_list
static void delete_regions(DVBSubContext *ctx)
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
#define DVBSUB_DISPLAYDEFINITION_SEGMENT
struct DVBSubRegion * next
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Various defines for YUV<->RGB conversion.
int y
top left corner of pict, undefined when pict is not set
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static DVBSubCLUT default_clut
static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
const char * name
Name of the codec implementation.
int64_t max_pixels
The number of pixels per image to maximally accept.
uint32_t end_display_time
int64_t pts
Same as packet pts, in AV_TIME_BASE.
struct DVBSubObject * next
AVCodec ff_dvbsub_decoder
A bitmap, pict will be set.
DVBSubObjectDisplay * display_list
struct DVBSubObjectDisplay * region_list_next
int width
picture width / height.
static int dvbsub_parse_clut_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
#define YUV_TO_RGB2_CCIR(r, g, b, y1)
static void compute_default_clut(DVBSubContext *ctx, uint8_t *clut, AVSubtitleRect *rect, int w, int h)
attribute_deprecated uint8_t * data[AV_NUM_DATA_POINTERS]
pointers to the image data planes
static int save_subtitle_set(AVCodecContext *avctx, AVSubtitle *sub, int *got_output)
DVBSubObjectDisplay * display_list
static void delete_objects(DVBSubContext *ctx)
DVBSubDisplayDefinition * display_definition
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define YUV_TO_RGB1_CCIR(cb1, cr1)
int clut_count2[257][256]
#define AV_LOG_INFO
Standard information.
#define DVBSUB_CLUT_SEGMENT
Libavcodec external API header.
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
static const int16_t alpha[]
main external API structure.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
static DVBSubObject * get_object(DVBSubContext *ctx, int object_id)
static unsigned int get_bits1(GetBitContext *s)
static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)
Describe the class of an AVClass context structure.
#define DVBSUB_DISPLAY_SEGMENT
struct DVBSubRegionDisplay * next
#define FF_COMPLIANCE_NORMAL
Rational number (pair of numerator and denominator).
struct DVBSubObjectDisplay * object_list_next
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
#define DVBSUB_PAGE_SEGMENT
static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static const AVOption options[]
#define DVBSUB_REGION_SEGMENT
GLint GLenum GLboolean GLsizei stride
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
#define xf(width, name, var, range_min, range_max, subs,...)
#define FF_DEBUG_STARTCODE
#define FF_ENABLE_DEPRECATION_WARNINGS
static int dvbsub_parse_object_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
DVBSubObject * object_list
static int dvbsub_read_2bit_string(AVCodecContext *avctx, uint8_t *destbuf, int dbuf_len, const uint8_t **srcbuf, int buf_size, int non_mod, uint8_t *map_table, int x_pos)
static float sub(float src0, float src1)
static int dvbsub_parse_region_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
#define FFSWAP(type, a, b)
int compute_edt
if 1 end display time calculated using pts if 0 (Default) calculated using time out ...
#define DVBSUB_OBJECT_SEGMENT
uint8_t computed_clut[4 *256]
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static double cr(void *priv, double x, double y)
static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
This structure stores compressed data.
FFmpeg currently uses a custom build system
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
#define AV_NOPTS_VALUE
Undefined timestamp value.
void * av_mallocz_array(size_t nmemb, size_t size)