FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/arbc.c
Date: 2022-10-02 18:56:10
Exec Total Coverage
Lines: 0 112 0.0%
Branches: 0 68 0.0%

Line Branch Exec Source
1 /*
2 * Gryphon's Anim Compressor decoder
3 * Copyright (c) 2019 Paul B Mahol
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include "libavutil/internal.h"
23 #include "libavutil/intreadwrite.h"
24
25 #include "avcodec.h"
26 #include "bytestream.h"
27 #include "codec_internal.h"
28 #include "decode.h"
29
30 typedef struct ARBCContext {
31 GetByteContext gb;
32
33 AVFrame *prev_frame;
34 } ARBCContext;
35
36 static int fill_tile4(AVCodecContext *avctx, int color, AVFrame *frame)
37 {
38 ARBCContext *s = avctx->priv_data;
39 GetByteContext *gb = &s->gb;
40 int nb_tiles = bytestream2_get_le16(gb);
41 int h = avctx->height - 1;
42 int pixels_overwritten = 0;
43
44 if ((avctx->width / 4 + 1) * (avctx->height / 4 + 1) < nb_tiles)
45 return 0;
46
47 for (int i = 0; i < nb_tiles; i++) {
48 int y = bytestream2_get_byte(gb);
49 int x = bytestream2_get_byte(gb);
50 uint16_t mask = bytestream2_get_le16(gb);
51 int start_y = y * 4, start_x = x * 4;
52 int end_y = start_y + 4, end_x = start_x + 4;
53
54 for (int j = start_y; j < end_y; j++) {
55 for (int k = start_x; k < end_x; k++) {
56 if (mask & 0x8000) {
57 if (j >= avctx->height || k >= avctx->width) {
58 mask = mask << 1;
59 continue;
60 }
61 AV_WB24(&frame->data[0][frame->linesize[0] * (h - j) + 3 * k], color);
62 pixels_overwritten ++;
63 }
64 mask = mask << 1;
65 }
66 }
67 }
68 return pixels_overwritten;
69 }
70
71 static int fill_tileX(AVCodecContext *avctx, int tile_width, int tile_height,
72 int color, AVFrame *frame)
73 {
74 ARBCContext *s = avctx->priv_data;
75 GetByteContext *gb = &s->gb;
76 const int step_h = tile_height / 4;
77 const int step_w = tile_width / 4;
78 int nb_tiles = bytestream2_get_le16(gb);
79 int h = avctx->height - 1;
80 int pixels_overwritten = 0;
81
82 if ((avctx->width / tile_width + 1) * (avctx->height / tile_height + 1) < nb_tiles)
83 return 0;
84
85 for (int i = 0; i < nb_tiles; i++) {
86 int y = bytestream2_get_byte(gb);
87 int x = bytestream2_get_byte(gb);
88 uint16_t mask = bytestream2_get_le16(gb);
89 int start_y = y * tile_height, start_x = x * tile_width;
90 int end_y = start_y + tile_height, end_x = start_x + tile_width;
91
92 if (start_x >= avctx->width || start_y >= avctx->height)
93 continue;
94
95 for (int j = start_y; j < end_y; j += step_h) {
96 for (int k = start_x; k < end_x; k += step_w) {
97 if (mask & 0x8000U) {
98 for (int m = 0; m < step_h; m++) {
99 for (int n = 0; n < step_w; n++) {
100 if (j + m >= avctx->height || k + n >= avctx->width)
101 continue;
102 AV_WB24(&frame->data[0][frame->linesize[0] * (h - (j + m)) + 3 * (k + n)], color);
103 }
104 }
105 pixels_overwritten += FFMIN(step_h, avctx->height - j) * FFMIN(step_w, avctx->width - k);
106 }
107 mask = mask << 1;
108 }
109 }
110 }
111 return pixels_overwritten;
112 }
113
114 static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
115 int *got_frame, AVPacket *avpkt)
116 {
117 ARBCContext *s = avctx->priv_data;
118 int ret, nb_segments;
119 int prev_pixels = avctx->width * avctx->height;
120
121 if (avpkt->size < 10)
122 return AVERROR_INVALIDDATA;
123
124 bytestream2_init(&s->gb, avpkt->data, avpkt->size);
125 bytestream2_skip(&s->gb, 8);
126 nb_segments = bytestream2_get_le16(&s->gb);
127 if (nb_segments == 0)
128 return avpkt->size;
129
130 if (7 * nb_segments > bytestream2_get_bytes_left(&s->gb))
131 return AVERROR_INVALIDDATA;
132
133 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
134 return ret;
135
136 if (s->prev_frame->data[0]) {
137 ret = av_frame_copy(frame, s->prev_frame);
138 if (ret < 0)
139 return ret;
140 }
141
142 for (int i = 0; i < nb_segments; i++) {
143 int resolution_flag;
144 int fill;
145
146 if (bytestream2_get_bytes_left(&s->gb) <= 0)
147 return AVERROR_INVALIDDATA;
148
149 fill = bytestream2_get_byte(&s->gb) << 16;
150 bytestream2_skip(&s->gb, 1);
151 fill |= bytestream2_get_byte(&s->gb) << 8;
152 bytestream2_skip(&s->gb, 1);
153 fill |= bytestream2_get_byte(&s->gb) << 0;
154 bytestream2_skip(&s->gb, 1);
155 resolution_flag = bytestream2_get_byte(&s->gb);
156
157 if (resolution_flag & 0x10)
158 prev_pixels -= fill_tileX(avctx, 1024, 1024, fill, frame);
159 if (resolution_flag & 0x08)
160 prev_pixels -= fill_tileX(avctx, 256, 256, fill, frame);
161 if (resolution_flag & 0x04)
162 prev_pixels -= fill_tileX(avctx, 64, 64, fill, frame);
163 if (resolution_flag & 0x02)
164 prev_pixels -= fill_tileX(avctx, 16, 16, fill, frame);
165 if (resolution_flag & 0x01)
166 prev_pixels -= fill_tile4(avctx, fill, frame);
167 }
168
169 av_frame_unref(s->prev_frame);
170 if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
171 return ret;
172
173 frame->pict_type = prev_pixels <= 0 ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
174 frame->key_frame = prev_pixels <= 0;
175 *got_frame = 1;
176
177 return avpkt->size;
178 }
179
180 static av_cold int decode_init(AVCodecContext *avctx)
181 {
182 ARBCContext *s = avctx->priv_data;
183
184 avctx->pix_fmt = AV_PIX_FMT_RGB24;
185
186 s->prev_frame = av_frame_alloc();
187 if (!s->prev_frame)
188 return AVERROR(ENOMEM);
189
190 return 0;
191 }
192
193 static void decode_flush(AVCodecContext *avctx)
194 {
195 ARBCContext *s = avctx->priv_data;
196
197 av_frame_unref(s->prev_frame);
198 }
199
200 static av_cold int decode_close(AVCodecContext *avctx)
201 {
202 ARBCContext *s = avctx->priv_data;
203
204 av_frame_free(&s->prev_frame);
205
206 return 0;
207 }
208
209 const FFCodec ff_arbc_decoder = {
210 .p.name = "arbc",
211 CODEC_LONG_NAME("Gryphon's Anim Compressor"),
212 .p.type = AVMEDIA_TYPE_VIDEO,
213 .p.id = AV_CODEC_ID_ARBC,
214 .priv_data_size = sizeof(ARBCContext),
215 .init = decode_init,
216 FF_CODEC_DECODE_CB(decode_frame),
217 .flush = decode_flush,
218 .close = decode_close,
219 .p.capabilities = AV_CODEC_CAP_DR1,
220 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
221 };
222