FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavcodec/bintext.c
Date:	2026-09-24 20:08:24

	Total	Coverage
Lines:	113	0.0%
Functions:	4	0.0%
Branches:	70	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Binary text decoder
    
       * eXtended BINary text (XBIN) decoder
    
       * iCEDraw File decoder
    
       * Copyright (c) 2010 Peter Ross (pross@xvid.org)
    
       *
    
       * This file is part of FFmpeg.
    
       *
    
       * FFmpeg is free software; you can redistribute it and/or
    
       * modify it under the terms of the GNU Lesser General Public
    
       * License as published by the Free Software Foundation; either
    
       * version 2.1 of the License, or (at your option) any later version.
    
       *
    
       * FFmpeg is distributed in the hope that it will be useful,
    
       * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
       * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
       * Lesser General Public License for more details.
    
       *
    
       * You should have received a copy of the GNU Lesser General Public
    
       * License along with FFmpeg; if not, write to the Free Software
    
       * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
    
       */
    
      /**
    
       * @file
    
       * Binary text decoder
    
       * eXtended BINary text (XBIN) decoder
    
       * iCEDraw File decoder
    
       */
    
      #include "config_components.h"
    
      #include "libavutil/attributes.h"
    
      #include "libavutil/intreadwrite.h"
    
      #include "libavutil/xga_font_data.h"
    
      #include "avcodec.h"
    
      #include "cga_data.h"
    
      #include "bintext.h"
    
      #include "codec_internal.h"
    
      #include "decode.h"
    
      #define FONT_WIDTH 8
    
      typedef struct XbinContext {
    
          AVFrame *frame;
    
          int palette[16];
    
          int flags;
    
          int font_height;
    
          const uint8_t *font;
    
          int x, y;
    
      } XbinContext;
    
      ✗
      static av_cold int decode_init(AVCodecContext *avctx)
    
      {
    
      ✗
          XbinContext *s = avctx->priv_data;
    
          uint8_t *p;
    
          int i;
    
      ✗
          avctx->pix_fmt = AV_PIX_FMT_PAL8;
    
      ✗
          p = avctx->extradata;
    
      ✗
          if (p) {
    
      ✗
              s->font_height = p[0];
    
      ✗
              s->flags = p[1];
    
      ✗
              p += 2;
    
      ✗
              if(avctx->extradata_size < 2 + (!!(s->flags & BINTEXT_PALETTE))*3*16
    
      ✗
                                           + (!!(s->flags & BINTEXT_FONT))*s->font_height*256) {
    
      ✗
                  av_log(avctx, AV_LOG_ERROR, "not enough extradata\n");
    
      ✗
                  return AVERROR_INVALIDDATA;
    
              }
    
      ✗
              if (!s->font_height) {
    
      ✗
                  av_log(avctx, AV_LOG_ERROR, "invalid font height\n");
    
      ✗
                  return AVERROR_INVALIDDATA;
    
              }
    
          } else {
    
      ✗
              s->font_height = 8;
    
      ✗
              s->flags = 0;
    
          }
    
      ✗
          if ((s->flags & BINTEXT_PALETTE)) {
    
      ✗
              for (i = 0; i < 16; i++) {
    
      ✗
                  s->palette[i] = 0xFF000000 | (AV_RB24(p) << 2) | ((AV_RB24(p) >> 4) & 0x30303);
    
      ✗
                  p += 3;
    
              }
    
          } else {
    
      ✗
              for (i = 0; i < 16; i++)
    
      ✗
                  s->palette[i] = 0xFF000000 | ff_cga_palette[i];
    
          }
    
      ✗
          if ((s->flags & BINTEXT_FONT)) {
    
      ✗
              s->font = p;
    
          } else {
    
      ✗
              switch(s->font_height) {
    
      ✗
              default:
    
      ✗
                  av_log(avctx, AV_LOG_WARNING, "font height %i not supported\n", s->font_height);
    
      ✗
                  s->font_height = 8;
    
                  av_fallthrough;
    
      ✗
              case 8:
    
      ✗
                  s->font = avpriv_cga_font_get();
    
      ✗
                  break;
    
      ✗
              case 16:
    
      ✗
                  s->font = avpriv_vga16_font_get();
    
      ✗
                  break;
    
              }
    
          }
    
      ✗
          if (avctx->width < FONT_WIDTH || avctx->height < s->font_height) {
    
      ✗
              av_log(avctx, AV_LOG_ERROR, "Resolution too small for font.\n");
    
      ✗
              return AVERROR_INVALIDDATA;
    
          }
    
      ✗
          return 0;
    
      }
    
      #define DEFAULT_BG_COLOR 0
    
      ✗
      av_unused static void hscroll(AVCodecContext *avctx)
    
      {
    
      ✗
          XbinContext *s = avctx->priv_data;
    
      ✗
          if (s->y < avctx->height - s->font_height) {
    
      ✗
              s->y += s->font_height;
    
          } else {
    
      ✗
              memmove(s->frame->data[0], s->frame->data[0] + s->font_height*s->frame->linesize[0],
    
      ✗
                  (avctx->height - s->font_height)*s->frame->linesize[0]);
    
      ✗
              memset(s->frame->data[0] + (avctx->height - s->font_height)*s->frame->linesize[0],
    
      ✗
                  DEFAULT_BG_COLOR, s->font_height * s->frame->linesize[0]);
    
          }
    
      ✗
      }
    
      /**
    
       * Draw character to screen
    
       */
    
      ✗
      static void draw_char(AVCodecContext *avctx, int c, int a)
    
      {
    
      ✗
          XbinContext *s = avctx->priv_data;
    
      ✗
          if (s->y > avctx->height - s->font_height)
    
      ✗
              return;
    
      ✗
          ff_draw_pc_font(s->frame->data[0] + s->y * s->frame->linesize[0] + s->x,
    
      ✗
                          s->frame->linesize[0], s->font, s->font_height, c,
    
                          a & 0x0F, a >> 4);
    
      ✗
          s->x += FONT_WIDTH;
    
      ✗
          if (s->x > avctx->width - FONT_WIDTH) {
    
      ✗
              s->x = 0;
    
      ✗
              s->y += s->font_height;
    
          }
    
      }
    
      ✗
      static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
    
                              int *got_frame, AVPacket *avpkt)
    
      {
    
      ✗
          XbinContext *s = avctx->priv_data;
    
      ✗
          const uint8_t *buf = avpkt->data;
    
      ✗
          int buf_size = avpkt->size;
    
      ✗
          const uint8_t *buf_end = buf+buf_size;
    
          int ret;
    
      ✗
          if ((avctx->width / FONT_WIDTH) * (avctx->height / s->font_height) / 256 > buf_size)
    
      ✗
              return AVERROR_INVALIDDATA;
    
      ✗
          s->frame = frame;
    
      ✗
          s->x = s->y = 0;
    
      ✗
          if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
    
      ✗
              return ret;
    
      ✗
          s->frame->pict_type           = AV_PICTURE_TYPE_I;
    
      ✗
          memcpy(s->frame->data[1], s->palette, 16 * 4);
    
      ✗
          if (avctx->codec_id == AV_CODEC_ID_XBIN) {
    
      ✗
              while (buf + 2 < buf_end) {
    
                  int i,c,a;
    
      ✗
                  int type  = *buf >> 6;
    
      ✗
                  int count = (*buf & 0x3F) + 1;
    
      ✗
                  buf++;
    
      ✗
                  switch (type) {
    
      ✗
                  case 0: //no compression
    
      ✗
                      for (i = 0; i < count && buf + 1 < buf_end; i++) {
    
      ✗
                          draw_char(avctx, buf[0], buf[1]);
    
      ✗
                          buf += 2;
    
                      }
    
      ✗
                      break;
    
      ✗
                  case 1: //character compression
    
      ✗
                      c = *buf++;
    
      ✗
                      for (i = 0; i < count && buf < buf_end; i++)
    
      ✗
                          draw_char(avctx, c, *buf++);
    
      ✗
                      break;
    
      ✗
                  case 2: //attribute compression
    
      ✗
                      a = *buf++;
    
      ✗
                      for (i = 0; i < count && buf < buf_end; i++)
    
      ✗
                          draw_char(avctx, *buf++, a);
    
      ✗
                      break;
    
      ✗
                  case 3: //character/attribute compression
    
      ✗
                      c = *buf++;
    
      ✗
                      a = *buf++;
    
      ✗
                      for (i = 0; i < count && buf < buf_end; i++)
    
      ✗
                          draw_char(avctx, c, a);
    
      ✗
                      break;
    
                  }
    
              }
    
      ✗
          } else if (avctx->codec_id == AV_CODEC_ID_IDF) {
    
      ✗
              while (buf + 2 < buf_end) {
    
      ✗
                  if (AV_RL16(buf) == 1) {
    
                     int i;
    
      ✗
                     if (buf + 6 > buf_end)
    
      ✗
                         break;
    
      ✗
                     for (i = 0; i < buf[2]; i++)
    
      ✗
                         draw_char(avctx, buf[4], buf[5]);
    
      ✗
                     buf += 6;
    
                  } else {
    
      ✗
                     draw_char(avctx, buf[0], buf[1]);
    
      ✗
                     buf += 2;
    
                  }
    
              }
    
          } else {
    
      ✗
              while (buf + 1 < buf_end) {
    
      ✗
                  draw_char(avctx, buf[0], buf[1]);
    
      ✗
                  buf += 2;
    
              }
    
          }
    
      ✗
          *got_frame      = 1;
    
      ✗
          return buf_size;
    
      }
    
      #if CONFIG_BINTEXT_DECODER
    
      const FFCodec ff_bintext_decoder = {
    
          .p.name         = "bintext",
    
          CODEC_LONG_NAME("Binary text"),
    
          .p.type         = AVMEDIA_TYPE_VIDEO,
    
          .p.id           = AV_CODEC_ID_BINTEXT,
    
          .priv_data_size = sizeof(XbinContext),
    
          .init           = decode_init,
    
          FF_CODEC_DECODE_CB(decode_frame),
    
          .p.capabilities = AV_CODEC_CAP_DR1,
    
      };
    
      #endif
    
      #if CONFIG_XBIN_DECODER
    
      const FFCodec ff_xbin_decoder = {
    
          .p.name         = "xbin",
    
          CODEC_LONG_NAME("eXtended BINary text"),
    
          .p.type         = AVMEDIA_TYPE_VIDEO,
    
          .p.id           = AV_CODEC_ID_XBIN,
    
          .priv_data_size = sizeof(XbinContext),
    
          .init           = decode_init,
    
          FF_CODEC_DECODE_CB(decode_frame),
    
          .p.capabilities = AV_CODEC_CAP_DR1,
    
      };
    
      #endif
    
      #if CONFIG_IDF_DECODER
    
      const FFCodec ff_idf_decoder = {
    
          .p.name         = "idf",
    
          CODEC_LONG_NAME("iCEDraw text"),
    
          .p.type         = AVMEDIA_TYPE_VIDEO,
    
          .p.id           = AV_CODEC_ID_IDF,
    
          .priv_data_size = sizeof(XbinContext),
    
          .init           = decode_init,
    
          FF_CODEC_DECODE_CB(decode_frame),
    
          .p.capabilities = AV_CODEC_CAP_DR1,
    
      };
    
      #endif

Line	Exec	Source
1		/*
2		* Binary text decoder
3		* eXtended BINary text (XBIN) decoder
4		* iCEDraw File decoder
5		* Copyright (c) 2010 Peter Ross (pross@xvid.org)
6		*
7		* This file is part of FFmpeg.
8		*
9		* FFmpeg is free software; you can redistribute it and/or
10		* modify it under the terms of the GNU Lesser General Public
11		* License as published by the Free Software Foundation; either
12		* version 2.1 of the License, or (at your option) any later version.
13		*
14		* FFmpeg is distributed in the hope that it will be useful,
15		* but WITHOUT ANY WARRANTY; without even the implied warranty of
16		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17		* Lesser General Public License for more details.
18		*
19		* You should have received a copy of the GNU Lesser General Public
20		* License along with FFmpeg; if not, write to the Free Software
21		* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22		*/
23
24		/**
25		* @file
26		* Binary text decoder
27		* eXtended BINary text (XBIN) decoder
28		* iCEDraw File decoder
29		*/
30
31		#include "config_components.h"
32
33		#include "libavutil/attributes.h"
34		#include "libavutil/intreadwrite.h"
35		#include "libavutil/xga_font_data.h"
36		#include "avcodec.h"
37		#include "cga_data.h"
38		#include "bintext.h"
39		#include "codec_internal.h"
40		#include "decode.h"
41
42		#define FONT_WIDTH 8
43
44		typedef struct XbinContext {
45		AVFrame *frame;
46		int palette[16];
47		int flags;
48		int font_height;
49		const uint8_t *font;
50		int x, y;
51		} XbinContext;
52
53	✗	static av_cold int decode_init(AVCodecContext *avctx)
54		{
55	✗	XbinContext *s = avctx->priv_data;
56		uint8_t *p;
57		int i;
58
59	✗	avctx->pix_fmt = AV_PIX_FMT_PAL8;
60	✗	p = avctx->extradata;
61	✗	if (p) {
62	✗	s->font_height = p[0];
63	✗	s->flags = p[1];
64	✗	p += 2;
65	✗	if(avctx->extradata_size < 2 + (!!(s->flags & BINTEXT_PALETTE))316
66	✗	+ (!!(s->flags & BINTEXT_FONT))s->font_height256) {
67	✗	av_log(avctx, AV_LOG_ERROR, "not enough extradata\n");
68	✗	return AVERROR_INVALIDDATA;
69		}
70	✗	if (!s->font_height) {
71	✗	av_log(avctx, AV_LOG_ERROR, "invalid font height\n");
72	✗	return AVERROR_INVALIDDATA;
73		}
74		} else {
75	✗	s->font_height = 8;
76	✗	s->flags = 0;
77		}
78
79	✗	if ((s->flags & BINTEXT_PALETTE)) {
80	✗	for (i = 0; i < 16; i++) {
81	✗	s->palette[i] = 0xFF000000 \| (AV_RB24(p) << 2) \| ((AV_RB24(p) >> 4) & 0x30303);
82	✗	p += 3;
83		}
84		} else {
85	✗	for (i = 0; i < 16; i++)
86	✗	s->palette[i] = 0xFF000000 \| ff_cga_palette[i];
87		}
88
89	✗	if ((s->flags & BINTEXT_FONT)) {
90	✗	s->font = p;
91		} else {
92	✗	switch(s->font_height) {
93	✗	default:
94	✗	av_log(avctx, AV_LOG_WARNING, "font height %i not supported\n", s->font_height);
95	✗	s->font_height = 8;
96		av_fallthrough;
97	✗	case 8:
98	✗	s->font = avpriv_cga_font_get();
99	✗	break;
100	✗	case 16:
101	✗	s->font = avpriv_vga16_font_get();
102	✗	break;
103		}
104		}
105	✗	if (avctx->width < FONT_WIDTH \|\| avctx->height < s->font_height) {
106	✗	av_log(avctx, AV_LOG_ERROR, "Resolution too small for font.\n");
107	✗	return AVERROR_INVALIDDATA;
108		}
109
110	✗	return 0;
111		}
112
113		#define DEFAULT_BG_COLOR 0
114	✗	av_unused static void hscroll(AVCodecContext *avctx)
115		{
116	✗	XbinContext *s = avctx->priv_data;
117	✗	if (s->y < avctx->height - s->font_height) {
118	✗	s->y += s->font_height;
119		} else {
120	✗	memmove(s->frame->data[0], s->frame->data[0] + s->font_height*s->frame->linesize[0],
121	✗	(avctx->height - s->font_height)*s->frame->linesize[0]);
122	✗	memset(s->frame->data[0] + (avctx->height - s->font_height)*s->frame->linesize[0],
123	✗	DEFAULT_BG_COLOR, s->font_height * s->frame->linesize[0]);
124		}
125	✗	}
126
127		/**
128		* Draw character to screen
129		*/
130	✗	static void draw_char(AVCodecContext *avctx, int c, int a)
131		{
132	✗	XbinContext *s = avctx->priv_data;
133	✗	if (s->y > avctx->height - s->font_height)
134	✗	return;
135	✗	ff_draw_pc_font(s->frame->data[0] + s->y * s->frame->linesize[0] + s->x,
136	✗	s->frame->linesize[0], s->font, s->font_height, c,
137		a & 0x0F, a >> 4);
138	✗	s->x += FONT_WIDTH;
139	✗	if (s->x > avctx->width - FONT_WIDTH) {
140	✗	s->x = 0;
141	✗	s->y += s->font_height;
142		}
143		}
144
145	✗	static int decode_frame(AVCodecContext avctx, AVFrame frame,
146		int got_frame, AVPacket avpkt)
147		{
148	✗	XbinContext *s = avctx->priv_data;
149	✗	const uint8_t *buf = avpkt->data;
150	✗	int buf_size = avpkt->size;
151	✗	const uint8_t *buf_end = buf+buf_size;
152		int ret;
153
154	✗	if ((avctx->width / FONT_WIDTH) * (avctx->height / s->font_height) / 256 > buf_size)
155	✗	return AVERROR_INVALIDDATA;
156
157	✗	s->frame = frame;
158	✗	s->x = s->y = 0;
159	✗	if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
160	✗	return ret;
161	✗	s->frame->pict_type = AV_PICTURE_TYPE_I;
162	✗	memcpy(s->frame->data[1], s->palette, 16 * 4);
163
164	✗	if (avctx->codec_id == AV_CODEC_ID_XBIN) {
165	✗	while (buf + 2 < buf_end) {
166		int i,c,a;
167	✗	int type = *buf >> 6;
168	✗	int count = (*buf & 0x3F) + 1;
169	✗	buf++;
170	✗	switch (type) {
171	✗	case 0: //no compression
172	✗	for (i = 0; i < count && buf + 1 < buf_end; i++) {
173	✗	draw_char(avctx, buf[0], buf[1]);
174	✗	buf += 2;
175		}
176	✗	break;
177	✗	case 1: //character compression
178	✗	c = *buf++;
179	✗	for (i = 0; i < count && buf < buf_end; i++)
180	✗	draw_char(avctx, c, *buf++);
181	✗	break;
182	✗	case 2: //attribute compression
183	✗	a = *buf++;
184	✗	for (i = 0; i < count && buf < buf_end; i++)
185	✗	draw_char(avctx, *buf++, a);
186	✗	break;
187	✗	case 3: //character/attribute compression
188	✗	c = *buf++;
189	✗	a = *buf++;
190	✗	for (i = 0; i < count && buf < buf_end; i++)
191	✗	draw_char(avctx, c, a);
192	✗	break;
193		}
194		}
195	✗	} else if (avctx->codec_id == AV_CODEC_ID_IDF) {
196	✗	while (buf + 2 < buf_end) {
197	✗	if (AV_RL16(buf) == 1) {
198		int i;
199	✗	if (buf + 6 > buf_end)
200	✗	break;
201	✗	for (i = 0; i < buf[2]; i++)
202	✗	draw_char(avctx, buf[4], buf[5]);
203	✗	buf += 6;
204		} else {
205	✗	draw_char(avctx, buf[0], buf[1]);
206	✗	buf += 2;
207		}
208		}
209		} else {
210	✗	while (buf + 1 < buf_end) {
211	✗	draw_char(avctx, buf[0], buf[1]);
212	✗	buf += 2;
213		}
214		}
215
216	✗	*got_frame = 1;
217	✗	return buf_size;
218		}
219
220		#if CONFIG_BINTEXT_DECODER
221		const FFCodec ff_bintext_decoder = {
222		.p.name = "bintext",
223		CODEC_LONG_NAME("Binary text"),
224		.p.type = AVMEDIA_TYPE_VIDEO,
225		.p.id = AV_CODEC_ID_BINTEXT,
226		.priv_data_size = sizeof(XbinContext),
227		.init = decode_init,
228		FF_CODEC_DECODE_CB(decode_frame),
229		.p.capabilities = AV_CODEC_CAP_DR1,
230		};
231		#endif
232		#if CONFIG_XBIN_DECODER
233		const FFCodec ff_xbin_decoder = {
234		.p.name = "xbin",
235		CODEC_LONG_NAME("eXtended BINary text"),
236		.p.type = AVMEDIA_TYPE_VIDEO,
237		.p.id = AV_CODEC_ID_XBIN,
238		.priv_data_size = sizeof(XbinContext),
239		.init = decode_init,
240		FF_CODEC_DECODE_CB(decode_frame),
241		.p.capabilities = AV_CODEC_CAP_DR1,
242		};
243		#endif
244		#if CONFIG_IDF_DECODER
245		const FFCodec ff_idf_decoder = {
246		.p.name = "idf",
247		CODEC_LONG_NAME("iCEDraw text"),
248		.p.type = AVMEDIA_TYPE_VIDEO,
249		.p.id = AV_CODEC_ID_IDF,
250		.priv_data_size = sizeof(XbinContext),
251		.init = decode_init,
252		FF_CODEC_DECODE_CB(decode_frame),
253		.p.capabilities = AV_CODEC_CAP_DR1,
254		};
255		#endif
256

Function (Line)	Call count	Block coverage
decode_frame (line 145)	not called	0.0%
decode_init (line 53)	not called	0.0%
draw_char (line 130)	not called	0.0%
hscroll (line 114)	not called	0.0%