Go to the documentation of this file.
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))
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;
198 obj2_ptr = &
ctx->object_list;
201 while (obj2 !=
object) {
203 obj2_ptr = &obj2->
next;
207 *obj2_ptr = obj2->
next;
223 while (
ctx->clut_list) {
234 while (
ctx->object_list) {
237 ctx->object_list =
object->next;
245 while (
ctx->region_list) {
248 ctx->region_list = region->
next;
259 int i,
r,
g,
b,
a = 0;
262 if (
ctx->substream < 0) {
263 ctx->composition_id = -1;
264 ctx->ancillary_id = -1;
267 ctx->composition_id = -1;
268 ctx->ancillary_id = -1;
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);
359 while (
ctx->display_list) {
360 display =
ctx->display_list;
361 ctx->display_list = display->
next;
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;
406 while (run_length-- > 0 && pixels_read < dbuf_len) {
419 if (non_mod == 1 &&
bits == 1)
420 pixels_read += run_length;
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;
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;
534 while (run_length-- > 0 && pixels_read < dbuf_len) {
545 if (non_mod == 1 &&
bits == 1)
546 pixels_read += run_length;
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;
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;
640 while (run_length-- > 0 && pixels_read < dbuf_len) {
658 int counttab[256] = {0};
659 int (*counttab2)[256] =
ctx->clut_count2;
663 memset(
ctx->clut_count2, 0 ,
sizeof(
ctx->clut_count2));
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;
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;
740 if (
sub->num_rects) {
744 for (display =
ctx->display_list; display; display = display->
next) {
746 if (region && region->
dirty)
750 if (
ctx->compute_edt == 0) {
751 sub->end_display_time =
ctx->time_out * 1000;
757 if (
sub->num_rects > 0) {
765 for (
i = 0;
i <
sub->num_rects;
i++) {
767 if (!
sub->rects[
i]) {
775 for (display =
ctx->display_list; display; display = display->
next) {
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++) {
841 rect->pict.linesize[j] =
rect->linesize[j];
854 for (
i=0;
i <
sub->num_rects;
i++) {
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++) {
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;
982 if (
ctx->compute_clut != -2)
987 const uint8_t *buf,
int buf_size)
991 const uint8_t *buf_end = buf + buf_size;
995 int top_field_len, bottom_field_len;
997 int coding_method, non_modifying_color;
1007 coding_method = ((*buf) >> 2) & 3;
1008 non_modifying_color = ((*buf++) >> 1) & 1;
1010 if (coding_method == 0) {
1013 bottom_field_len =
AV_RB16(buf);
1016 if (buf + top_field_len + bottom_field_len > buf_end) {
1017 av_log(avctx,
AV_LOG_ERROR,
"Field data size %d+%d too large\n", top_field_len, bottom_field_len);
1023 int bfl = bottom_field_len;
1026 non_modifying_color);
1028 if (bottom_field_len > 0)
1029 block = buf + top_field_len;
1031 bfl = top_field_len;
1034 non_modifying_color);
1036 }
else if (coding_method == 1) {
1039 }
else if (coding_method == 2) {
1051 const uint8_t *buf,
int buf_size)
1055 const uint8_t *buf_end = buf + buf_size;
1061 int r,
g,
b, r_add, g_add, b_add;
1063 ff_dlog(avctx,
"DVB clut packet:\n");
1065 for (
i=0;
i < buf_size;
i++) {
1091 ctx->clut_list = clut;
1098 while (buf + 4 < buf_end) {
1101 depth = (*buf) & 0xe0;
1116 cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;
1117 cb = (buf[1] << 2) & 0xf0;
1118 alpha = (buf[1] << 6) & 0xc0;
1129 ff_dlog(avctx,
"clut %d := (%d,%d,%d,%d)\n", entry_id,
r,
g,
b,
alpha);
1130 if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {
1131 ff_dlog(avctx,
"More than one bit level marked: %x\n", depth);
1136 if (depth & 0x80 && entry_id < 4)
1138 else if (depth & 0x40 && entry_id < 16)
1140 else if (depth & 0x20)
1150 const uint8_t *buf,
int buf_size)
1154 const uint8_t *buf_end = buf + buf_size;
1155 int region_id, object_id;
1175 region->
id = region_id;
1178 region->
next =
ctx->region_list;
1179 ctx->region_list = region;
1183 fill = ((*buf++) >> 3) & 1;
1191 if (
ret >= 0 && region->
width * region->
height * 2 > 320 * 1024 * 8) {
1206 if (!region->
pbuf) {
1217 region->
depth = 1 << (((*buf++) >> 2) & 7);
1218 if (region->
depth < 2 || region->
depth > 8) {
1222 region->
clut = *buf++;
1224 if (region->
depth == 8) {
1230 if (region->
depth == 4)
1231 region->
bgcolor = (((*buf++) >> 4) & 15);
1233 region->
bgcolor = (((*buf++) >> 2) & 3);
1245 while (buf + 5 < buf_end) {
1256 object->id = object_id;
1257 object->next =
ctx->object_list;
1258 ctx->object_list = object;
1261 object->
type = (*buf) >> 6;
1282 if ((object->
type == 1 || object->
type == 2) && buf+1 < buf_end) {
1291 object->display_list = display;
1304 const uint8_t *buf_end = buf + buf_size;
1315 page_state = ((*buf++) >> 2) & 3;
1321 ctx->time_out = timeout;
1324 ff_dlog(avctx,
"Page time out %ds, state %d\n",
ctx->time_out, page_state);
1326 if (
ctx->compute_edt == 1)
1329 if (page_state == 1 || page_state == 2) {
1335 tmp_display_list =
ctx->display_list;
1338 while (buf + 5 < buf_end) {
1342 display =
ctx->display_list;
1343 while (display && display->
region_id != region_id) {
1344 display = display->
next;
1351 display = tmp_display_list;
1352 tmp_ptr = &tmp_display_list;
1354 while (display && display->
region_id != region_id) {
1355 tmp_ptr = &display->
next;
1356 display = display->
next;
1372 *tmp_ptr = display->
next;
1374 display->
next =
ctx->display_list;
1375 ctx->display_list = display;
1377 ff_dlog(avctx,
"Region %d, (%d,%d)\n", region_id, display->
x_pos, display->
y_pos);
1380 while (tmp_display_list) {
1381 display = tmp_display_list;
1383 tmp_display_list = display->
next;
1393 static void png_save(
DVBSubContext *
ctx,
const char *filename, uint32_t *bitmap,
int w,
int h)
1397 char fname[40], fname2[40];
1400 snprintf(fname,
sizeof(fname),
"%s.ppm", filename);
1402 f = fopen(fname,
"w");
1411 for(y = 0; y <
h; y++) {
1412 for(x = 0; x <
w; x++) {
1413 v = bitmap[y *
w + x];
1414 putc((v >> 16) & 0xff,
f);
1415 putc((v >> 8) & 0xff,
f);
1416 putc((v >> 0) & 0xff,
f);
1422 snprintf(fname2,
sizeof(fname2),
"%s-a.pgm", filename);
1424 f = fopen(fname2,
"w");
1433 for(y = 0; y <
h; y++) {
1434 for(x = 0; x <
w; x++) {
1435 v = bitmap[y *
w + x];
1436 putc((v >> 24) & 0xff,
f);
1441 snprintf(
command,
sizeof(
command),
"pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
1459 uint32_t *clut_table;
1461 int x, y, y_off, x_off;
1464 static int fileno_index = 0;
1471 for (display =
ctx->display_list; display; display = display->
next) {
1478 x_pos = display->
x_pos;
1479 y_pos = display->
y_pos;
1483 if (display->
x_pos < x_pos) {
1485 x_pos = display->
x_pos;
1488 if (display->
y_pos < y_pos) {
1490 y_pos = display->
y_pos;
1509 for (display =
ctx->display_list; display; display = display->
next) {
1515 x_off = display->
x_pos - x_pos;
1516 y_off = display->
y_pos - y_pos;
1523 switch (region->
depth) {
1525 clut_table = clut->
clut4;
1532 clut_table = clut->
clut16;
1536 for (y = 0; y < region->
height; y++) {
1537 for (x = 0; x < region->
width; x++) {
1538 pbuf[((y + y_off) *
width) + x_off + x] =
1539 clut_table[region->
pbuf[y * region->
width + x]];
1545 snprintf(filename,
sizeof(filename),
"dvbs.%d", fileno_index);
1563 int dds_version, info_byte;
1568 info_byte = bytestream_get_byte(&buf);
1569 dds_version = info_byte >> 4;
1570 if (display_def && display_def->
version == dds_version)
1574 display_def =
av_mallocz(
sizeof(*display_def));
1577 ctx->display_definition = display_def;
1580 display_def->
version = dds_version;
1583 display_def->
width = bytestream_get_be16(&buf) + 1;
1584 display_def->
height = bytestream_get_be16(&buf) + 1;
1591 if (info_byte & 1<<3) {
1595 display_def->
x = bytestream_get_be16(&buf);
1596 display_def->
width = bytestream_get_be16(&buf) - display_def->
x + 1;
1597 display_def->
y = bytestream_get_be16(&buf);
1598 display_def->
height = bytestream_get_be16(&buf) - display_def->
y + 1;
1609 if (
ctx->compute_edt == 0)
1612 save_display_set(
ctx);
1618 void *
data,
int *got_sub_ptr,
1622 int buf_size = avpkt->
size;
1631 int got_segment = 0;
1634 ff_dlog(avctx,
"DVB sub packet:\n");
1636 for (
i=0;
i < buf_size;
i++) {
1645 if (buf_size <= 6 || *buf != 0x0f) {
1646 ff_dlog(avctx,
"incomplete or broken packet");
1651 p_end = buf + buf_size;
1653 while (p_end - p >= 6 && *p == 0x0f) {
1655 segment_type = *p++;
1662 av_log(avctx,
AV_LOG_DEBUG,
"segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length);
1665 if (p_end - p < segment_length) {
1666 ff_dlog(avctx,
"incomplete or broken packet");
1671 if (page_id ==
ctx->composition_id || page_id ==
ctx->ancillary_id ||
1672 ctx->composition_id == -1 ||
ctx->ancillary_id == -1) {
1674 switch (segment_type) {
1685 if (
ret < 0)
goto end;
1699 if (got_segment == 15 && !got_dds && !avctx->
width && !avctx->
height) {
1707 ff_dlog(avctx,
"Subtitling segment type 0x%x, page id %d, length %d\n",
1708 segment_type, page_id, segment_length);
1715 p += segment_length;
1719 if (got_segment == 15) {
1730 if (
ctx->compute_edt == 1)
1737 #define DS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_SUBTITLE_PARAM
1738 #define OFFSET(x) offsetof(DVBSubContext, x)
1740 {
"compute_edt",
"compute end of time using pts or timeout",
OFFSET(compute_edt),
AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
DS},
1741 {
"compute_clut",
"compute clut when not available(-1) or only once (-2) or always(1) or never(0)",
OFFSET(compute_clut),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -2, 1,
DS},
#define FF_ENABLE_DEPRECATION_WARNINGS
#define AV_LOG_WARNING
Something somehow does not look correct.
#define DVBSUB_DISPLAY_SEGMENT
static av_cold int init(AVCodecContext *avctx)
static void delete_cluts(DVBSubContext *ctx)
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
#define FFSWAP(type, a, b)
static double cb(void *priv, double x, double y)
static float sub(float src0, float src1)
static const AVClass dvbsubdec_class
static DVBSubRegion * get_region(DVBSubContext *ctx, int region_id)
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
static int dvbsub_parse_region_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
static int get_bits_count(const GetBitContext *s)
int compute_edt
if 1 end display time calculated using pts if 0 (Default) calculated using time out
static const AVOption options[]
#define DVBSUB_PAGE_SEGMENT
DVBSubObjectDisplay * display_list
void * av_mallocz_array(size_t nmemb, size_t size)
#define YUV_TO_RGB1_CCIR(cb1, cr1)
static void delete_objects(DVBSubContext *ctx)
DVBSubRegionDisplay * display_list
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static void compute_default_clut(DVBSubContext *ctx, uint8_t *clut, AVSubtitleRect *rect, int w, int h)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static DVBSubObject * get_object(DVBSubContext *ctx, int object_id)
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...
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
@ AV_CODEC_ID_DVB_SUBTITLE
DVBSubRegion * region_list
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
#define DVBSUB_DISPLAYDEFINITION_SEGMENT
DVBSubObjectDisplay * display_list
#define av_assert0(cond)
assert() equivalent, that is always enabled.
struct DVBSubObjectDisplay * region_list_next
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
#define DVBSUB_CLUT_SEGMENT
int64_t max_pixels
The number of pixels per image to maximally accept.
AVCodec ff_dvbsub_decoder
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
static void delete_regions(DVBSubContext *ctx)
#define DVBSUB_OBJECT_SEGMENT
static int dvbsub_decode(AVCodecContext *avctx, void *data, int *got_sub_ptr, AVPacket *avpkt)
static int save_subtitle_set(AVCodecContext *avctx, AVSubtitle *sub, int *got_output)
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)
Rational number (pair of numerator and denominator).
static int dvbsub_parse_clut_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
FFmpeg currently uses a custom build system
const char * av_default_item_name(void *ptr)
Return the context name.
static unsigned int get_bits1(GetBitContext *s)
static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display, const uint8_t *buf, int buf_size, int top_bottom, int non_mod)
#define DVBSUB_REGION_SEGMENT
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
#define YUV_TO_RGB2_CCIR(r, g, b, y1)
static int dvbsub_parse_object_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
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)
struct DVBSubRegion * next
static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define AV_NOPTS_VALUE
Undefined timestamp value.
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
DVBSubDisplayDefinition * display_definition
static DVBSubCLUT * get_clut(DVBSubContext *ctx, int clut_id)
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
#define FF_COMPLIANCE_NORMAL
static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)
@ SUBTITLE_BITMAP
A bitmap, pict will be set.
#define AV_LOG_INFO
Standard information.
struct DVBSubObject * next
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
#define xf(width, name, var, range_min, range_max, subs,...)
#define FF_DEBUG_STARTCODE
static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
uint8_t computed_clut[4 *256]
main external API structure.
static DVBSubCLUT default_clut
#define FF_DISABLE_DEPRECATION_WARNINGS
int clut_count2[257][256]
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.
#define avpriv_request_sample(...)
struct DVBSubObjectDisplay * object_list_next
static const int16_t alpha[]
DVBSubObject * object_list
This structure stores compressed data.
static double cr(void *priv, double x, double y)
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 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)
int width
picture width / height.
The exact code depends on how similar the blocks are and how related they are to the block
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int dvbsub_parse_page_segment(AVCodecContext *avctx, const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)
struct DVBSubRegionDisplay * next
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