1 /*
2 * Copyright (c) 2019 Paul B Mahol
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <stdint.h>
22 #include <zlib.h>
23
24 #include "libavutil/frame.h"
25 #include "libavutil/error.h"
26 #include "libavutil/log.h"
27
28 #include "avcodec.h"
29 #include "bytestream.h"
30 #include "codec.h"
31 #include "internal.h"
32 #include "packet.h"
33 #include "png.h"
34 #include "pngdsp.h"
35
36 typedef struct LSCRContext {
37 PNGDSPContext dsp;
38 AVCodecContext *avctx;
39
40 AVFrame *last_picture;
41 uint8_t *buffer;
42 int buffer_size;
43 uint8_t *crow_buf;
44 int crow_size;
45 uint8_t *last_row;
46 unsigned int last_row_size;
47
48 GetByteContext gb;
49 uint8_t *image_buf;
50 int image_linesize;
51 int row_size;
52 int cur_h;
53 int y;
54
55 z_stream zstream;
56 } LSCRContext;
57
handle_row(LSCRContext * s)58 static void handle_row(LSCRContext *s)
59 {
60 uint8_t *ptr, *last_row;
61
62 ptr = s->image_buf + s->image_linesize * s->y;
63 if (s->y == 0)
64 last_row = s->last_row;
65 else
66 last_row = ptr - s->image_linesize;
67
68 ff_png_filter_row(&s->dsp, ptr, s->crow_buf[0], s->crow_buf + 1,
69 last_row, s->row_size, 3);
70
71 s->y++;
72 }
73
decode_idat(LSCRContext * s,int length)74 static int decode_idat(LSCRContext *s, int length)
75 {
76 int ret;
77 s->zstream.avail_in = FFMIN(length, bytestream2_get_bytes_left(&s->gb));
78 s->zstream.next_in = s->gb.buffer;
79
80 if (length <= 0)
81 return AVERROR_INVALIDDATA;
82
83 bytestream2_skip(&s->gb, length);
84
85 /* decode one line if possible */
86 while (s->zstream.avail_in > 0) {
87 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
88 if (ret != Z_OK && ret != Z_STREAM_END) {
89 av_log(s->avctx, AV_LOG_ERROR, "inflate returned error %d\n", ret);
90 return AVERROR_EXTERNAL;
91 }
92 if (s->zstream.avail_out == 0) {
93 if (s->y < s->cur_h) {
94 handle_row(s);
95 }
96 s->zstream.avail_out = s->crow_size;
97 s->zstream.next_out = s->crow_buf;
98 }
99 if (ret == Z_STREAM_END && s->zstream.avail_in > 0) {
100 av_log(s->avctx, AV_LOG_WARNING,
101 "%d undecompressed bytes left in buffer\n", s->zstream.avail_in);
102 return 0;
103 }
104 }
105 return 0;
106 }
107
decode_frame_lscr(AVCodecContext * avctx,void * data,int * got_frame,AVPacket * avpkt)108 static int decode_frame_lscr(AVCodecContext *avctx,
109 void *data, int *got_frame,
110 AVPacket *avpkt)
111 {
112 LSCRContext *const s = avctx->priv_data;
113 GetByteContext *gb = &s->gb;
114 AVFrame *frame = s->last_picture;
115 int ret, nb_blocks, offset = 0;
116
117 if (avpkt->size < 2)
118 return AVERROR_INVALIDDATA;
119 if (avpkt->size == 2)
120 return 0;
121
122 bytestream2_init(gb, avpkt->data, avpkt->size);
123
124 nb_blocks = bytestream2_get_le16(gb);
125 if (bytestream2_get_bytes_left(gb) < 2 + nb_blocks * (12 + 8))
126 return AVERROR_INVALIDDATA;
127
128 ret = ff_reget_buffer(avctx, frame,
129 nb_blocks ? 0 : FF_REGET_BUFFER_FLAG_READONLY);
130 if (ret < 0)
131 return ret;
132
133 for (int b = 0; b < nb_blocks; b++) {
134 int x, y, x2, y2, w, h, left;
135 uint32_t csize, size;
136
137 s->zstream.zalloc = ff_png_zalloc;
138 s->zstream.zfree = ff_png_zfree;
139 s->zstream.opaque = NULL;
140
141 if ((ret = inflateInit(&s->zstream)) != Z_OK) {
142 av_log(avctx, AV_LOG_ERROR, "inflateInit returned error %d\n", ret);
143 ret = AVERROR_EXTERNAL;
144 goto end;
145 }
146
147 bytestream2_seek(gb, 2 + b * 12, SEEK_SET);
148
149 x = bytestream2_get_le16(gb);
150 y = bytestream2_get_le16(gb);
151 x2 = bytestream2_get_le16(gb);
152 y2 = bytestream2_get_le16(gb);
153 w = x2-x;
154 s->cur_h = h = y2-y;
155
156 if (w <= 0 || x < 0 || x >= avctx->width || w + x > avctx->width ||
157 h <= 0 || y < 0 || y >= avctx->height || h + y > avctx->height) {
158 ret = AVERROR_INVALIDDATA;
159 goto end;
160 }
161
162 size = bytestream2_get_le32(gb);
163
164 frame->key_frame = (nb_blocks == 1) &&
165 (w == avctx->width) &&
166 (h == avctx->height) &&
167 (x == 0) && (y == 0);
168
169 bytestream2_seek(gb, 2 + nb_blocks * 12 + offset, SEEK_SET);
170 csize = bytestream2_get_be32(gb);
171 if (bytestream2_get_le32(gb) != MKTAG('I', 'D', 'A', 'T')) {
172 ret = AVERROR_INVALIDDATA;
173 goto end;
174 }
175
176 offset += size;
177 left = size;
178
179 s->y = 0;
180 s->row_size = w * 3;
181
182 av_fast_padded_malloc(&s->buffer, &s->buffer_size, s->row_size + 16);
183 if (!s->buffer) {
184 ret = AVERROR(ENOMEM);
185 goto end;
186 }
187
188 av_fast_padded_malloc(&s->last_row, &s->last_row_size, s->row_size);
189 if (!s->last_row) {
190 ret = AVERROR(ENOMEM);
191 goto end;
192 }
193
194 s->crow_size = w * 3 + 1;
195 s->crow_buf = s->buffer + 15;
196 s->zstream.avail_out = s->crow_size;
197 s->zstream.next_out = s->crow_buf;
198 s->image_buf = frame->data[0] + (avctx->height - y - 1) * frame->linesize[0] + x * 3;
199 s->image_linesize =-frame->linesize[0];
200
201 while (left > 16) {
202 ret = decode_idat(s, csize);
203 if (ret < 0)
204 goto end;
205 left -= csize + 16;
206 if (left > 16) {
207 bytestream2_skip(gb, 4);
208 csize = bytestream2_get_be32(gb);
209 if (bytestream2_get_le32(gb) != MKTAG('I', 'D', 'A', 'T')) {
210 ret = AVERROR_INVALIDDATA;
211 goto end;
212 }
213 }
214 }
215
216 inflateEnd(&s->zstream);
217 }
218
219 frame->pict_type = frame->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
220
221 if ((ret = av_frame_ref(data, frame)) < 0)
222 return ret;
223
224 *got_frame = 1;
225 end:
226 inflateEnd(&s->zstream);
227
228 if (ret < 0)
229 return ret;
230 return avpkt->size;
231 }
232
lscr_decode_close(AVCodecContext * avctx)233 static int lscr_decode_close(AVCodecContext *avctx)
234 {
235 LSCRContext *s = avctx->priv_data;
236
237 av_frame_free(&s->last_picture);
238 av_freep(&s->buffer);
239 av_freep(&s->last_row);
240
241 return 0;
242 }
243
lscr_decode_init(AVCodecContext * avctx)244 static int lscr_decode_init(AVCodecContext *avctx)
245 {
246 LSCRContext *s = avctx->priv_data;
247
248 avctx->color_range = AVCOL_RANGE_JPEG;
249 avctx->pix_fmt = AV_PIX_FMT_BGR24;
250
251 s->avctx = avctx;
252 s->last_picture = av_frame_alloc();
253 if (!s->last_picture)
254 return AVERROR(ENOMEM);
255
256 ff_pngdsp_init(&s->dsp);
257
258 return 0;
259 }
260
lscr_decode_flush(AVCodecContext * avctx)261 static void lscr_decode_flush(AVCodecContext *avctx)
262 {
263 LSCRContext *s = avctx->priv_data;
264 av_frame_unref(s->last_picture);
265 }
266
267 AVCodec ff_lscr_decoder = {
268 .name = "lscr",
269 .long_name = NULL_IF_CONFIG_SMALL("LEAD Screen Capture"),
270 .type = AVMEDIA_TYPE_VIDEO,
271 .id = AV_CODEC_ID_LSCR,
272 .priv_data_size = sizeof(LSCRContext),
273 .init = lscr_decode_init,
274 .close = lscr_decode_close,
275 .decode = decode_frame_lscr,
276 .flush = lscr_decode_flush,
277 .capabilities = AV_CODEC_CAP_DR1,
278 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
279 };
280