FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavcodec/bintext.c
Date:	2024-04-26 14:42:52

	Total	Coverage
Lines:	114	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/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;
    
      ✗
              case 8:
    
      ✗
                  s->font = avpriv_cga_font;
    
      ✗
                  break;
    
      ✗
              case 16:
    
      ✗
                  s->font = avpriv_vga16_font;
    
      ✗
                  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;
    
      #if FF_API_PALETTE_HAS_CHANGED
    
      FF_DISABLE_DEPRECATION_WARNINGS
    
      ✗
          s->frame->palette_has_changed = 1;
    
      FF_ENABLE_DEPRECATION_WARNINGS
    
      #endif
    
      ✗
          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/intreadwrite.h"
34		#include "libavutil/xga_font_data.h"
35		#include "avcodec.h"
36		#include "cga_data.h"
37		#include "bintext.h"
38		#include "codec_internal.h"
39		#include "decode.h"
40
41		#define FONT_WIDTH 8
42
43		typedef struct XbinContext {
44		AVFrame *frame;
45		int palette[16];
46		int flags;
47		int font_height;
48		const uint8_t *font;
49		int x, y;
50		} XbinContext;
51
52	✗	static av_cold int decode_init(AVCodecContext *avctx)
53		{
54	✗	XbinContext *s = avctx->priv_data;
55		uint8_t *p;
56		int i;
57
58	✗	avctx->pix_fmt = AV_PIX_FMT_PAL8;
59	✗	p = avctx->extradata;
60	✗	if (p) {
61	✗	s->font_height = p[0];
62	✗	s->flags = p[1];
63	✗	p += 2;
64	✗	if(avctx->extradata_size < 2 + (!!(s->flags & BINTEXT_PALETTE))316
65	✗	+ (!!(s->flags & BINTEXT_FONT))s->font_height256) {
66	✗	av_log(avctx, AV_LOG_ERROR, "not enough extradata\n");
67	✗	return AVERROR_INVALIDDATA;
68		}
69	✗	if (!s->font_height) {
70	✗	av_log(avctx, AV_LOG_ERROR, "invalid font height\n");
71	✗	return AVERROR_INVALIDDATA;
72		}
73		} else {
74	✗	s->font_height = 8;
75	✗	s->flags = 0;
76		}
77
78	✗	if ((s->flags & BINTEXT_PALETTE)) {
79	✗	for (i = 0; i < 16; i++) {
80	✗	s->palette[i] = 0xFF000000 \| (AV_RB24(p) << 2) \| ((AV_RB24(p) >> 4) & 0x30303);
81	✗	p += 3;
82		}
83		} else {
84	✗	for (i = 0; i < 16; i++)
85	✗	s->palette[i] = 0xFF000000 \| ff_cga_palette[i];
86		}
87
88	✗	if ((s->flags & BINTEXT_FONT)) {
89	✗	s->font = p;
90		} else {
91	✗	switch(s->font_height) {
92	✗	default:
93	✗	av_log(avctx, AV_LOG_WARNING, "font height %i not supported\n", s->font_height);
94	✗	s->font_height = 8;
95	✗	case 8:
96	✗	s->font = avpriv_cga_font;
97	✗	break;
98	✗	case 16:
99	✗	s->font = avpriv_vga16_font;
100	✗	break;
101		}
102		}
103	✗	if (avctx->width < FONT_WIDTH \|\| avctx->height < s->font_height) {
104	✗	av_log(avctx, AV_LOG_ERROR, "Resolution too small for font.\n");
105	✗	return AVERROR_INVALIDDATA;
106		}
107
108	✗	return 0;
109		}
110
111		#define DEFAULT_BG_COLOR 0
112	✗	av_unused static void hscroll(AVCodecContext *avctx)
113		{
114	✗	XbinContext *s = avctx->priv_data;
115	✗	if (s->y < avctx->height - s->font_height) {
116	✗	s->y += s->font_height;
117		} else {
118	✗	memmove(s->frame->data[0], s->frame->data[0] + s->font_height*s->frame->linesize[0],
119	✗	(avctx->height - s->font_height)*s->frame->linesize[0]);
120	✗	memset(s->frame->data[0] + (avctx->height - s->font_height)*s->frame->linesize[0],
121	✗	DEFAULT_BG_COLOR, s->font_height * s->frame->linesize[0]);
122		}
123	✗	}
124
125		/**
126		* Draw character to screen
127		*/
128	✗	static void draw_char(AVCodecContext *avctx, int c, int a)
129		{
130	✗	XbinContext *s = avctx->priv_data;
131	✗	if (s->y > avctx->height - s->font_height)
132	✗	return;
133	✗	ff_draw_pc_font(s->frame->data[0] + s->y * s->frame->linesize[0] + s->x,
134	✗	s->frame->linesize[0], s->font, s->font_height, c,
135		a & 0x0F, a >> 4);
136	✗	s->x += FONT_WIDTH;
137	✗	if (s->x > avctx->width - FONT_WIDTH) {
138	✗	s->x = 0;
139	✗	s->y += s->font_height;
140		}
141		}
142
143	✗	static int decode_frame(AVCodecContext avctx, AVFrame frame,
144		int got_frame, AVPacket avpkt)
145		{
146	✗	XbinContext *s = avctx->priv_data;
147	✗	const uint8_t *buf = avpkt->data;
148	✗	int buf_size = avpkt->size;
149	✗	const uint8_t *buf_end = buf+buf_size;
150		int ret;
151
152	✗	if ((avctx->width / FONT_WIDTH) * (avctx->height / s->font_height) / 256 > buf_size)
153	✗	return AVERROR_INVALIDDATA;
154
155	✗	s->frame = frame;
156	✗	s->x = s->y = 0;
157	✗	if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
158	✗	return ret;
159	✗	s->frame->pict_type = AV_PICTURE_TYPE_I;
160		#if FF_API_PALETTE_HAS_CHANGED
161		FF_DISABLE_DEPRECATION_WARNINGS
162	✗	s->frame->palette_has_changed = 1;
163		FF_ENABLE_DEPRECATION_WARNINGS
164		#endif
165	✗	memcpy(s->frame->data[1], s->palette, 16 * 4);
166
167	✗	if (avctx->codec_id == AV_CODEC_ID_XBIN) {
168	✗	while (buf + 2 < buf_end) {
169		int i,c,a;
170	✗	int type = *buf >> 6;
171	✗	int count = (*buf & 0x3F) + 1;
172	✗	buf++;
173	✗	switch (type) {
174	✗	case 0: //no compression
175	✗	for (i = 0; i < count && buf + 1 < buf_end; i++) {
176	✗	draw_char(avctx, buf[0], buf[1]);
177	✗	buf += 2;
178		}
179	✗	break;
180	✗	case 1: //character compression
181	✗	c = *buf++;
182	✗	for (i = 0; i < count && buf < buf_end; i++)
183	✗	draw_char(avctx, c, *buf++);
184	✗	break;
185	✗	case 2: //attribute compression
186	✗	a = *buf++;
187	✗	for (i = 0; i < count && buf < buf_end; i++)
188	✗	draw_char(avctx, *buf++, a);
189	✗	break;
190	✗	case 3: //character/attribute compression
191	✗	c = *buf++;
192	✗	a = *buf++;
193	✗	for (i = 0; i < count && buf < buf_end; i++)
194	✗	draw_char(avctx, c, a);
195	✗	break;
196		}
197		}
198	✗	} else if (avctx->codec_id == AV_CODEC_ID_IDF) {
199	✗	while (buf + 2 < buf_end) {
200	✗	if (AV_RL16(buf) == 1) {
201		int i;
202	✗	if (buf + 6 > buf_end)
203	✗	break;
204	✗	for (i = 0; i < buf[2]; i++)
205	✗	draw_char(avctx, buf[4], buf[5]);
206	✗	buf += 6;
207		} else {
208	✗	draw_char(avctx, buf[0], buf[1]);
209	✗	buf += 2;
210		}
211		}
212		} else {
213	✗	while (buf + 1 < buf_end) {
214	✗	draw_char(avctx, buf[0], buf[1]);
215	✗	buf += 2;
216		}
217		}
218
219	✗	*got_frame = 1;
220	✗	return buf_size;
221		}
222
223		#if CONFIG_BINTEXT_DECODER
224		const FFCodec ff_bintext_decoder = {
225		.p.name = "bintext",
226		CODEC_LONG_NAME("Binary text"),
227		.p.type = AVMEDIA_TYPE_VIDEO,
228		.p.id = AV_CODEC_ID_BINTEXT,
229		.priv_data_size = sizeof(XbinContext),
230		.init = decode_init,
231		FF_CODEC_DECODE_CB(decode_frame),
232		.p.capabilities = AV_CODEC_CAP_DR1,
233		};
234		#endif
235		#if CONFIG_XBIN_DECODER
236		const FFCodec ff_xbin_decoder = {
237		.p.name = "xbin",
238		CODEC_LONG_NAME("eXtended BINary text"),
239		.p.type = AVMEDIA_TYPE_VIDEO,
240		.p.id = AV_CODEC_ID_XBIN,
241		.priv_data_size = sizeof(XbinContext),
242		.init = decode_init,
243		FF_CODEC_DECODE_CB(decode_frame),
244		.p.capabilities = AV_CODEC_CAP_DR1,
245		};
246		#endif
247		#if CONFIG_IDF_DECODER
248		const FFCodec ff_idf_decoder = {
249		.p.name = "idf",
250		CODEC_LONG_NAME("iCEDraw text"),
251		.p.type = AVMEDIA_TYPE_VIDEO,
252		.p.id = AV_CODEC_ID_IDF,
253		.priv_data_size = sizeof(XbinContext),
254		.init = decode_init,
255		FF_CODEC_DECODE_CB(decode_frame),
256		.p.capabilities = AV_CODEC_CAP_DR1,
257		};
258		#endif
259

Function (Line)	Call count	Block coverage
decode_frame (line 143)	not called	0.0%
decode_init (line 52)	not called	0.0%
draw_char (line 128)	not called	0.0%
hscroll (line 112)	not called	0.0%