FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavcodec/mvha.c
Date:	2026-09-26 14:26:21

	Total	Coverage
Lines:	149	0.0%
Functions:	5	0.0%
Branches:	74	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * MidiVid Archive codec
    
       *
    
       * Copyright (c) 2019 Paul B Mahol
    
       *
    
       * 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
    
       */
    
      #define CACHED_BITSTREAM_READER !ARCH_X86_32
    
      #include "libavutil/intreadwrite.h"
    
      #include "avcodec.h"
    
      #include "codec_internal.h"
    
      #include "decode.h"
    
      #include "get_bits.h"
    
      #include "lossless_videodsp.h"
    
      #include "zlib_wrapper.h"
    
      #include <zlib.h>
    
      typedef struct MVHAContext {
    
          GetBitContext     gb;
    
          int nb_symbols;
    
          uint8_t           symb[256];
    
          uint32_t          prob[256];
    
          VLC               vlc;
    
          FFZStream         zstream;
    
          LLVidDSPContext   llviddsp;
    
      } MVHAContext;
    
      typedef struct Node {
    
          int16_t  sym;
    
          int16_t  n0;
    
          int16_t  l, r;
    
          uint32_t count;
    
      } Node;
    
      ✗
      static void get_tree_codes(uint32_t *bits, int16_t *lens, uint8_t *xlat,
    
                                 Node *nodes, int node,
    
                                 uint32_t pfx, int pl, int *pos)
    
      {
    
          int s;
    
      ✗
          s = nodes[node].sym;
    
      ✗
          if (s != -1) {
    
      ✗
              bits[*pos] = (~pfx) & ((1ULL << FFMAX(pl, 1)) - 1);
    
      ✗
              lens[*pos] = FFMAX(pl, 1);
    
      ✗
              xlat[*pos] = s + (pl == 0);
    
      ✗
              (*pos)++;
    
          } else {
    
      ✗
              pfx <<= 1;
    
      ✗
              pl++;
    
      ✗
              get_tree_codes(bits, lens, xlat, nodes, nodes[node].l, pfx, pl,
    
                             pos);
    
      ✗
              pfx |= 1;
    
      ✗
              get_tree_codes(bits, lens, xlat, nodes, nodes[node].r, pfx, pl,
    
                             pos);
    
          }
    
      ✗
      }
    
      ✗
      static int build_vlc(AVCodecContext *avctx, VLC *vlc)
    
      {
    
      ✗
          MVHAContext *s = avctx->priv_data;
    
          Node nodes[512];
    
          uint32_t bits[256];
    
          int16_t lens[256];
    
          uint8_t xlat[256];
    
      ✗
          int cur_node, i, j, pos = 0;
    
      ✗
          ff_vlc_free(vlc);
    
      ✗
          for (i = 0; i < s->nb_symbols; i++) {
    
      ✗
              nodes[i].count = s->prob[i];
    
      ✗
              nodes[i].sym   = s->symb[i];
    
      ✗
              nodes[i].n0    = -2;
    
      ✗
              nodes[i].l     = i;
    
      ✗
              nodes[i].r     = i;
    
          }
    
      ✗
          cur_node = s->nb_symbols;
    
      ✗
          j = 0;
    
          do {
    
      ✗
              for (i = 0; ; i++) {
    
      ✗
                  int new_node = j;
    
      ✗
                  int first_node = cur_node;
    
      ✗
                  int second_node = cur_node;
    
                  unsigned nd, st;
    
      ✗
                  nodes[cur_node].count = -1;
    
                  do {
    
      ✗
                      int val = nodes[new_node].count;
    
      ✗
                      if (val && (val < nodes[first_node].count)) {
    
      ✗
                          if (val >= nodes[second_node].count) {
    
      ✗
                              first_node = new_node;
    
                          } else {
    
      ✗
                              first_node = second_node;
    
      ✗
                              second_node = new_node;
    
                          }
    
                      }
    
      ✗
                      new_node += 1;
    
      ✗
                  } while (new_node != cur_node);
    
      ✗
                  if (first_node == cur_node)
    
      ✗
                      break;
    
      ✗
                  nd = nodes[second_node].count;
    
      ✗
                  st = nodes[first_node].count;
    
      ✗
                  nodes[second_node].count = 0;
    
      ✗
                  nodes[first_node].count  = 0;
    
      ✗
                  if (nd >= UINT32_MAX - st) {
    
      ✗
                      av_log(avctx, AV_LOG_ERROR, "count overflow\n");
    
      ✗
                      return AVERROR_INVALIDDATA;
    
                  }
    
      ✗
                  nodes[cur_node].count = nd + st;
    
      ✗
                  nodes[cur_node].sym = -1;
    
      ✗
                  nodes[cur_node].n0 = cur_node;
    
      ✗
                  nodes[cur_node].l = first_node;
    
      ✗
                  nodes[cur_node].r = second_node;
    
      ✗
                  cur_node++;
    
              }
    
      ✗
              j++;
    
      ✗
          } while (cur_node - s->nb_symbols == j);
    
      ✗
          get_tree_codes(bits, lens, xlat, nodes, cur_node - 1, 0, 0, &pos);
    
      ✗
          return ff_vlc_init_sparse(vlc, 12, pos, lens, 2, 2, bits, 4, 4, xlat, 1, 1, 0);
    
      }
    
      ✗
      static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
    
                              int *got_frame, AVPacket *avpkt)
    
      {
    
      ✗
          MVHAContext *s = avctx->priv_data;
    
          uint32_t type, size;
    
          int ret;
    
      ✗
          if (avpkt->size <= 8)
    
      ✗
              return AVERROR_INVALIDDATA;
    
      ✗
          type = AV_RB32(avpkt->data);
    
      ✗
          size = AV_RL32(avpkt->data + 4);
    
      ✗
          if (size < 1 || size >= avpkt->size)
    
      ✗
              return AVERROR_INVALIDDATA;
    
      ✗
          if (type == MKTAG('L','Z','Y','V')) {
    
      ✗
              z_stream *const zstream = &s->zstream.zstream;
    
      ✗
              ret = inflateReset(zstream);
    
      ✗
              if (ret != Z_OK) {
    
      ✗
                  av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
    
      ✗
                  return AVERROR_EXTERNAL;
    
              }
    
      ✗
              if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
    
      ✗
                  return ret;
    
      ✗
              zstream->next_in  = avpkt->data + 8;
    
      ✗
              zstream->avail_in = avpkt->size - 8;
    
      ✗
              for (int p = 0; p < 3; p++) {
    
      ✗
                  for (int y = 0; y < avctx->height; y++) {
    
      ✗
                      zstream->next_out  = frame->data[p] + (avctx->height - y - 1) * frame->linesize[p];
    
      ✗
                      zstream->avail_out = avctx->width >> (p > 0);
    
      ✗
                      ret = inflate(zstream, Z_SYNC_FLUSH);
    
      ✗
                      if (ret != Z_OK && ret != Z_STREAM_END) {
    
      ✗
                          av_log(avctx, AV_LOG_ERROR, "Inflate error: %d\n", ret);
    
      ✗
                          return AVERROR_EXTERNAL;
    
                      }
    
      ✗
                      if (zstream->avail_out > 0)
    
      ✗
                          memset(zstream->next_out, 0, zstream->avail_out);
    
                  }
    
              }
    
      ✗
          } else if (type == MKTAG('H','U','F','Y')) {
    
      ✗
              GetBitContext *gb = &s->gb;
    
              int first_symbol, symbol;
    
      ✗
              ret = init_get_bits8(gb, avpkt->data + 8, avpkt->size - 8);
    
      ✗
              if (ret < 0)
    
      ✗
                  return ret;
    
      ✗
              skip_bits(gb, 24);
    
      ✗
              first_symbol = get_bits(gb, 8);
    
      ✗
              s->nb_symbols = get_bits(gb, 8) + 1;
    
      ✗
              symbol = first_symbol;
    
      ✗
              for (int i = 0; i < s->nb_symbols; symbol++) {
    
                  int prob;
    
      ✗
                  if (get_bits_left(gb) < 4)
    
      ✗
                      return AVERROR_INVALIDDATA;
    
      ✗
                  if (get_bits1(gb)) {
    
      ✗
                      prob = get_bits(gb, 12);
    
                  } else {
    
      ✗
                      prob = get_bits(gb, 3);
    
                  }
    
      ✗
                  if (prob) {
    
      ✗
                      s->symb[i] = symbol;
    
      ✗
                      s->prob[i] = prob;
    
      ✗
                      i++;
    
                  }
    
              }
    
      ✗
              if (get_bits_left(gb) < avctx->height * avctx->width)
    
      ✗
                  return AVERROR_INVALIDDATA;
    
      ✗
              ret = build_vlc(avctx, &s->vlc);
    
      ✗
              if (ret < 0)
    
      ✗
                  return ret;
    
      ✗
              if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
    
      ✗
                  return ret;
    
      ✗
              for (int p = 0; p < 3; p++) {
    
      ✗
                  int width = avctx->width >> (p > 0);
    
      ✗
                  ptrdiff_t stride = frame->linesize[p];
    
                  uint8_t *dst;
    
      ✗
                  dst = frame->data[p] + (avctx->height - 1) * frame->linesize[p];
    
      ✗
                  for (int y = 0; y < avctx->height; y++) {
    
      ✗
                      if (get_bits_left(gb) < width)
    
      ✗
                          return AVERROR_INVALIDDATA;
    
      ✗
                      for (int x = 0; x < width; x++) {
    
      ✗
                          int v = get_vlc2(gb, s->vlc.table, s->vlc.bits, 3);
    
      ✗
                          if (v < 0)
    
      ✗
                              return AVERROR_INVALIDDATA;
    
      ✗
                          dst[x] = v;
    
                      }
    
      ✗
                      dst -= stride;
    
                  }
    
              }
    
          } else {
    
      ✗
              return AVERROR_INVALIDDATA;
    
          }
    
      ✗
          for (int p = 0; p < 3; p++) {
    
              int left, lefttop;
    
      ✗
              int width = avctx->width >> (p > 0);
    
      ✗
              ptrdiff_t stride = frame->linesize[p];
    
              uint8_t *dst;
    
      ✗
              dst = frame->data[p] + (avctx->height - 1) * frame->linesize[p];
    
      ✗
              s->llviddsp.add_left_pred(dst, dst, width, 0);
    
      ✗
              if (avctx->height > 1) {
    
      ✗
                  dst -= stride;
    
      ✗
                  lefttop = left = dst[0];
    
      ✗
                  for (int y = 1; y < avctx->height; y++) {
    
      ✗
                      s->llviddsp.add_median_pred(dst, dst + stride, dst, width, &left, &lefttop);
    
      ✗
                      lefttop = left = dst[0];
    
      ✗
                      dst -= stride;
    
                  }
    
              }
    
          }
    
      ✗
          *got_frame = 1;
    
      ✗
          return avpkt->size;
    
      }
    
      ✗
      static av_cold int decode_init(AVCodecContext *avctx)
    
      {
    
      ✗
          MVHAContext *s = avctx->priv_data;
    
      ✗
          avctx->pix_fmt = AV_PIX_FMT_YUV422P;
    
      ✗
          ff_llviddsp_init(&s->llviddsp);
    
      ✗
          return ff_inflate_init(&s->zstream, avctx);
    
      }
    
      ✗
      static av_cold int decode_close(AVCodecContext *avctx)
    
      {
    
      ✗
          MVHAContext *s = avctx->priv_data;
    
      ✗
          ff_inflate_end(&s->zstream);
    
      ✗
          ff_vlc_free(&s->vlc);
    
      ✗
          return 0;
    
      }
    
      const FFCodec ff_mvha_decoder = {
    
          .p.name           = "mvha",
    
          CODEC_LONG_NAME("MidiVid Archive Codec"),
    
          .p.type           = AVMEDIA_TYPE_VIDEO,
    
          .p.id             = AV_CODEC_ID_MVHA,
    
          .priv_data_size   = sizeof(MVHAContext),
    
          .init             = decode_init,
    
          .close            = decode_close,
    
          FF_CODEC_DECODE_CB(decode_frame),
    
          .p.capabilities   = AV_CODEC_CAP_DR1,
    
          .caps_internal    = FF_CODEC_CAP_INIT_CLEANUP,
    
      };

Line	Exec	Source
1		/*
2		* MidiVid Archive codec
3		*
4		* Copyright (c) 2019 Paul B Mahol
5		*
6		* This file is part of FFmpeg.
7		*
8		* FFmpeg is free software; you can redistribute it and/or
9		* modify it under the terms of the GNU Lesser General Public
10		* License as published by the Free Software Foundation; either
11		* version 2.1 of the License, or (at your option) any later version.
12		*
13		* FFmpeg is distributed in the hope that it will be useful,
14		* but WITHOUT ANY WARRANTY; without even the implied warranty of
15		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16		* Lesser General Public License for more details.
17		*
18		* You should have received a copy of the GNU Lesser General Public
19		* License along with FFmpeg; if not, write to the Free Software
20		* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21		*/
22
23		#define CACHED_BITSTREAM_READER !ARCH_X86_32
24		#include "libavutil/intreadwrite.h"
25
26		#include "avcodec.h"
27		#include "codec_internal.h"
28		#include "decode.h"
29		#include "get_bits.h"
30		#include "lossless_videodsp.h"
31		#include "zlib_wrapper.h"
32
33		#include <zlib.h>
34
35		typedef struct MVHAContext {
36		GetBitContext gb;
37		int nb_symbols;
38
39		uint8_t symb[256];
40		uint32_t prob[256];
41		VLC vlc;
42
43		FFZStream zstream;
44		LLVidDSPContext llviddsp;
45		} MVHAContext;
46
47		typedef struct Node {
48		int16_t sym;
49		int16_t n0;
50		int16_t l, r;
51		uint32_t count;
52		} Node;
53
54	✗	static void get_tree_codes(uint32_t bits, int16_t lens, uint8_t *xlat,
55		Node *nodes, int node,
56		uint32_t pfx, int pl, int *pos)
57		{
58		int s;
59
60	✗	s = nodes[node].sym;
61	✗	if (s != -1) {
62	✗	bits[*pos] = (~pfx) & ((1ULL << FFMAX(pl, 1)) - 1);
63	✗	lens[*pos] = FFMAX(pl, 1);
64	✗	xlat[*pos] = s + (pl == 0);
65	✗	(*pos)++;
66		} else {
67	✗	pfx <<= 1;
68	✗	pl++;
69	✗	get_tree_codes(bits, lens, xlat, nodes, nodes[node].l, pfx, pl,
70		pos);
71	✗	pfx \|= 1;
72	✗	get_tree_codes(bits, lens, xlat, nodes, nodes[node].r, pfx, pl,
73		pos);
74		}
75	✗	}
76
77	✗	static int build_vlc(AVCodecContext avctx, VLC vlc)
78		{
79	✗	MVHAContext *s = avctx->priv_data;
80		Node nodes[512];
81		uint32_t bits[256];
82		int16_t lens[256];
83		uint8_t xlat[256];
84	✗	int cur_node, i, j, pos = 0;
85
86	✗	ff_vlc_free(vlc);
87
88	✗	for (i = 0; i < s->nb_symbols; i++) {
89	✗	nodes[i].count = s->prob[i];
90	✗	nodes[i].sym = s->symb[i];
91	✗	nodes[i].n0 = -2;
92	✗	nodes[i].l = i;
93	✗	nodes[i].r = i;
94		}
95
96	✗	cur_node = s->nb_symbols;
97	✗	j = 0;
98		do {
99	✗	for (i = 0; ; i++) {
100	✗	int new_node = j;
101	✗	int first_node = cur_node;
102	✗	int second_node = cur_node;
103		unsigned nd, st;
104
105	✗	nodes[cur_node].count = -1;
106
107		do {
108	✗	int val = nodes[new_node].count;
109	✗	if (val && (val < nodes[first_node].count)) {
110	✗	if (val >= nodes[second_node].count) {
111	✗	first_node = new_node;
112		} else {
113	✗	first_node = second_node;
114	✗	second_node = new_node;
115		}
116		}
117	✗	new_node += 1;
118	✗	} while (new_node != cur_node);
119
120	✗	if (first_node == cur_node)
121	✗	break;
122
123	✗	nd = nodes[second_node].count;
124	✗	st = nodes[first_node].count;
125	✗	nodes[second_node].count = 0;
126	✗	nodes[first_node].count = 0;
127	✗	if (nd >= UINT32_MAX - st) {
128	✗	av_log(avctx, AV_LOG_ERROR, "count overflow\n");
129	✗	return AVERROR_INVALIDDATA;
130		}
131	✗	nodes[cur_node].count = nd + st;
132	✗	nodes[cur_node].sym = -1;
133	✗	nodes[cur_node].n0 = cur_node;
134	✗	nodes[cur_node].l = first_node;
135	✗	nodes[cur_node].r = second_node;
136	✗	cur_node++;
137		}
138	✗	j++;
139	✗	} while (cur_node - s->nb_symbols == j);
140
141	✗	get_tree_codes(bits, lens, xlat, nodes, cur_node - 1, 0, 0, &pos);
142
143	✗	return ff_vlc_init_sparse(vlc, 12, pos, lens, 2, 2, bits, 4, 4, xlat, 1, 1, 0);
144		}
145
146	✗	static int decode_frame(AVCodecContext avctx, AVFrame frame,
147		int got_frame, AVPacket avpkt)
148		{
149	✗	MVHAContext *s = avctx->priv_data;
150		uint32_t type, size;
151		int ret;
152
153	✗	if (avpkt->size <= 8)
154	✗	return AVERROR_INVALIDDATA;
155
156	✗	type = AV_RB32(avpkt->data);
157	✗	size = AV_RL32(avpkt->data + 4);
158
159	✗	if (size < 1 \|\| size >= avpkt->size)
160	✗	return AVERROR_INVALIDDATA;
161
162	✗	if (type == MKTAG('L','Z','Y','V')) {
163	✗	z_stream *const zstream = &s->zstream.zstream;
164	✗	ret = inflateReset(zstream);
165	✗	if (ret != Z_OK) {
166	✗	av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
167	✗	return AVERROR_EXTERNAL;
168		}
169
170	✗	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
171	✗	return ret;
172
173	✗	zstream->next_in = avpkt->data + 8;
174	✗	zstream->avail_in = avpkt->size - 8;
175
176	✗	for (int p = 0; p < 3; p++) {
177	✗	for (int y = 0; y < avctx->height; y++) {
178	✗	zstream->next_out = frame->data[p] + (avctx->height - y - 1) * frame->linesize[p];
179	✗	zstream->avail_out = avctx->width >> (p > 0);
180
181	✗	ret = inflate(zstream, Z_SYNC_FLUSH);
182	✗	if (ret != Z_OK && ret != Z_STREAM_END) {
183	✗	av_log(avctx, AV_LOG_ERROR, "Inflate error: %d\n", ret);
184	✗	return AVERROR_EXTERNAL;
185		}
186	✗	if (zstream->avail_out > 0)
187	✗	memset(zstream->next_out, 0, zstream->avail_out);
188		}
189		}
190	✗	} else if (type == MKTAG('H','U','F','Y')) {
191	✗	GetBitContext *gb = &s->gb;
192		int first_symbol, symbol;
193
194	✗	ret = init_get_bits8(gb, avpkt->data + 8, avpkt->size - 8);
195	✗	if (ret < 0)
196	✗	return ret;
197
198	✗	skip_bits(gb, 24);
199
200	✗	first_symbol = get_bits(gb, 8);
201	✗	s->nb_symbols = get_bits(gb, 8) + 1;
202
203	✗	symbol = first_symbol;
204	✗	for (int i = 0; i < s->nb_symbols; symbol++) {
205		int prob;
206
207	✗	if (get_bits_left(gb) < 4)
208	✗	return AVERROR_INVALIDDATA;
209
210	✗	if (get_bits1(gb)) {
211	✗	prob = get_bits(gb, 12);
212		} else {
213	✗	prob = get_bits(gb, 3);
214		}
215
216	✗	if (prob) {
217	✗	s->symb[i] = symbol;
218	✗	s->prob[i] = prob;
219	✗	i++;
220		}
221		}
222
223	✗	if (get_bits_left(gb) < avctx->height * avctx->width)
224	✗	return AVERROR_INVALIDDATA;
225
226	✗	ret = build_vlc(avctx, &s->vlc);
227	✗	if (ret < 0)
228	✗	return ret;
229
230	✗	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
231	✗	return ret;
232
233	✗	for (int p = 0; p < 3; p++) {
234	✗	int width = avctx->width >> (p > 0);
235	✗	ptrdiff_t stride = frame->linesize[p];
236		uint8_t *dst;
237
238	✗	dst = frame->data[p] + (avctx->height - 1) * frame->linesize[p];
239	✗	for (int y = 0; y < avctx->height; y++) {
240	✗	if (get_bits_left(gb) < width)
241	✗	return AVERROR_INVALIDDATA;
242	✗	for (int x = 0; x < width; x++) {
243	✗	int v = get_vlc2(gb, s->vlc.table, s->vlc.bits, 3);
244
245	✗	if (v < 0)
246	✗	return AVERROR_INVALIDDATA;
247
248	✗	dst[x] = v;
249		}
250	✗	dst -= stride;
251		}
252		}
253		} else {
254	✗	return AVERROR_INVALIDDATA;
255		}
256
257	✗	for (int p = 0; p < 3; p++) {
258		int left, lefttop;
259	✗	int width = avctx->width >> (p > 0);
260	✗	ptrdiff_t stride = frame->linesize[p];
261		uint8_t *dst;
262
263	✗	dst = frame->data[p] + (avctx->height - 1) * frame->linesize[p];
264	✗	s->llviddsp.add_left_pred(dst, dst, width, 0);
265	✗	if (avctx->height > 1) {
266	✗	dst -= stride;
267	✗	lefttop = left = dst[0];
268	✗	for (int y = 1; y < avctx->height; y++) {
269	✗	s->llviddsp.add_median_pred(dst, dst + stride, dst, width, &left, &lefttop);
270	✗	lefttop = left = dst[0];
271	✗	dst -= stride;
272		}
273		}
274		}
275
276	✗	*got_frame = 1;
277
278	✗	return avpkt->size;
279		}
280
281	✗	static av_cold int decode_init(AVCodecContext *avctx)
282		{
283	✗	MVHAContext *s = avctx->priv_data;
284
285	✗	avctx->pix_fmt = AV_PIX_FMT_YUV422P;
286
287	✗	ff_llviddsp_init(&s->llviddsp);
288
289	✗	return ff_inflate_init(&s->zstream, avctx);
290		}
291
292	✗	static av_cold int decode_close(AVCodecContext *avctx)
293		{
294	✗	MVHAContext *s = avctx->priv_data;
295
296	✗	ff_inflate_end(&s->zstream);
297	✗	ff_vlc_free(&s->vlc);
298
299	✗	return 0;
300		}
301
302		const FFCodec ff_mvha_decoder = {
303		.p.name = "mvha",
304		CODEC_LONG_NAME("MidiVid Archive Codec"),
305		.p.type = AVMEDIA_TYPE_VIDEO,
306		.p.id = AV_CODEC_ID_MVHA,
307		.priv_data_size = sizeof(MVHAContext),
308		.init = decode_init,
309		.close = decode_close,
310		FF_CODEC_DECODE_CB(decode_frame),
311		.p.capabilities = AV_CODEC_CAP_DR1,
312		.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
313		};
314

Function (Line)	Call count	Block coverage
build_vlc (line 77)	not called	0.0%
decode_close (line 292)	not called	0.0%
decode_frame (line 146)	not called	0.0%
decode_init (line 281)	not called	0.0%
get_tree_codes (line 54)	not called	0.0%