| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | * MidiVid 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/imgutils.h" | ||
| 23 | #include "libavutil/internal.h" | ||
| 24 | #include "libavutil/mem.h" | ||
| 25 | |||
| 26 | #define BITSTREAM_READER_LE | ||
| 27 | #include "avcodec.h" | ||
| 28 | #include "get_bits.h" | ||
| 29 | #include "bytestream.h" | ||
| 30 | #include "codec_internal.h" | ||
| 31 | #include "decode.h" | ||
| 32 | |||
| 33 | typedef struct MidiVidContext { | ||
| 34 | GetByteContext gb; | ||
| 35 | |||
| 36 | uint8_t *uncompressed; | ||
| 37 | unsigned int uncompressed_size; | ||
| 38 | uint8_t *skip; | ||
| 39 | |||
| 40 | AVFrame *frame; | ||
| 41 | } MidiVidContext; | ||
| 42 | |||
| 43 | ✗ | static int decode_mvdv(MidiVidContext *s, AVCodecContext *avctx, AVFrame *frame) | |
| 44 | { | ||
| 45 | ✗ | GetByteContext *gb = &s->gb; | |
| 46 | GetBitContext mask; | ||
| 47 | GetByteContext idx9; | ||
| 48 | uint16_t nb_vectors, intra_flag; | ||
| 49 | const uint8_t *vec; | ||
| 50 | const uint8_t *mask_start; | ||
| 51 | uint8_t *skip; | ||
| 52 | uint32_t mask_size; | ||
| 53 | ✗ | int idx9bits = 0; | |
| 54 | ✗ | int idx9val = 0; | |
| 55 | uint32_t nb_blocks; | ||
| 56 | |||
| 57 | ✗ | nb_vectors = bytestream2_get_le16(gb); | |
| 58 | ✗ | intra_flag = !!bytestream2_get_le16(gb); | |
| 59 | ✗ | if (intra_flag) { | |
| 60 | ✗ | nb_blocks = (avctx->width / 2) * (avctx->height / 2); | |
| 61 | } else { | ||
| 62 | int ret, skip_linesize, padding; | ||
| 63 | |||
| 64 | ✗ | nb_blocks = bytestream2_get_le32(gb); | |
| 65 | ✗ | skip_linesize = avctx->width >> 1; | |
| 66 | ✗ | mask_start = gb->buffer_start + bytestream2_tell(gb); | |
| 67 | ✗ | mask_size = (FFALIGN(avctx->width, 32) >> 2) * (avctx->height >> 2) >> 3; | |
| 68 | ✗ | padding = (FFALIGN(avctx->width, 32) - avctx->width) >> 2; | |
| 69 | |||
| 70 | ✗ | if (bytestream2_get_bytes_left(gb) < mask_size) | |
| 71 | ✗ | return AVERROR_INVALIDDATA; | |
| 72 | |||
| 73 | ✗ | ret = init_get_bits8(&mask, mask_start, mask_size); | |
| 74 | ✗ | if (ret < 0) | |
| 75 | ✗ | return ret; | |
| 76 | ✗ | bytestream2_skip(gb, mask_size); | |
| 77 | ✗ | skip = s->skip; | |
| 78 | |||
| 79 | ✗ | for (int y = 0; y < avctx->height >> 2; y++) { | |
| 80 | ✗ | for (int x = 0; x < avctx->width >> 2; x++) { | |
| 81 | ✗ | int flag = !get_bits1(&mask); | |
| 82 | |||
| 83 | ✗ | skip[(y*2) *skip_linesize + x*2 ] = flag; | |
| 84 | ✗ | skip[(y*2) *skip_linesize + x*2+1] = flag; | |
| 85 | ✗ | skip[(y*2+1)*skip_linesize + x*2 ] = flag; | |
| 86 | ✗ | skip[(y*2+1)*skip_linesize + x*2+1] = flag; | |
| 87 | } | ||
| 88 | ✗ | skip_bits_long(&mask, padding); | |
| 89 | } | ||
| 90 | } | ||
| 91 | |||
| 92 | ✗ | vec = gb->buffer_start + bytestream2_tell(gb); | |
| 93 | ✗ | if (bytestream2_get_bytes_left(gb) < nb_vectors * 12) | |
| 94 | ✗ | return AVERROR_INVALIDDATA; | |
| 95 | ✗ | bytestream2_skip(gb, nb_vectors * 12); | |
| 96 | ✗ | if (nb_vectors > 256) { | |
| 97 | ✗ | if (bytestream2_get_bytes_left(gb) < (nb_blocks + 7 * !intra_flag) / 8) | |
| 98 | ✗ | return AVERROR_INVALIDDATA; | |
| 99 | ✗ | bytestream2_init(&idx9, gb->buffer_start + bytestream2_tell(gb), (nb_blocks + 7 * !intra_flag) / 8); | |
| 100 | ✗ | bytestream2_skip(gb, (nb_blocks + 7 * !intra_flag) / 8); | |
| 101 | } | ||
| 102 | |||
| 103 | ✗ | skip = s->skip; | |
| 104 | |||
| 105 | ✗ | for (int y = avctx->height - 2; y >= 0; y -= 2) { | |
| 106 | ✗ | uint8_t *dsty = frame->data[0] + y * frame->linesize[0]; | |
| 107 | ✗ | uint8_t *dstu = frame->data[1] + y * frame->linesize[1]; | |
| 108 | ✗ | uint8_t *dstv = frame->data[2] + y * frame->linesize[2]; | |
| 109 | |||
| 110 | ✗ | for (int x = 0; x < avctx->width; x += 2) { | |
| 111 | int idx; | ||
| 112 | |||
| 113 | ✗ | if (!intra_flag && *skip++) | |
| 114 | ✗ | continue; | |
| 115 | ✗ | if (bytestream2_get_bytes_left(gb) <= 0) | |
| 116 | ✗ | return AVERROR_INVALIDDATA; | |
| 117 | ✗ | if (nb_vectors <= 256) { | |
| 118 | ✗ | idx = bytestream2_get_byte(gb); | |
| 119 | } else { | ||
| 120 | ✗ | if (idx9bits == 0) { | |
| 121 | ✗ | idx9val = bytestream2_get_byte(&idx9); | |
| 122 | ✗ | idx9bits = 8; | |
| 123 | } | ||
| 124 | ✗ | idx9bits--; | |
| 125 | ✗ | idx = bytestream2_get_byte(gb) | (((idx9val >> (7 - idx9bits)) & 1) << 8); | |
| 126 | } | ||
| 127 | ✗ | if (idx >= nb_vectors) | |
| 128 | ✗ | return AVERROR_INVALIDDATA; | |
| 129 | |||
| 130 | ✗ | dsty[x +frame->linesize[0]] = vec[idx * 12 + 0]; | |
| 131 | ✗ | dsty[x+1+frame->linesize[0]] = vec[idx * 12 + 3]; | |
| 132 | ✗ | dsty[x] = vec[idx * 12 + 6]; | |
| 133 | ✗ | dsty[x+1] = vec[idx * 12 + 9]; | |
| 134 | |||
| 135 | ✗ | dstu[x +frame->linesize[1]] = vec[idx * 12 + 1]; | |
| 136 | ✗ | dstu[x+1+frame->linesize[1]] = vec[idx * 12 + 4]; | |
| 137 | ✗ | dstu[x] = vec[idx * 12 + 7]; | |
| 138 | ✗ | dstu[x+1] = vec[idx * 12 +10]; | |
| 139 | |||
| 140 | ✗ | dstv[x +frame->linesize[2]] = vec[idx * 12 + 2]; | |
| 141 | ✗ | dstv[x+1+frame->linesize[2]] = vec[idx * 12 + 5]; | |
| 142 | ✗ | dstv[x] = vec[idx * 12 + 8]; | |
| 143 | ✗ | dstv[x+1] = vec[idx * 12 +11]; | |
| 144 | } | ||
| 145 | } | ||
| 146 | |||
| 147 | ✗ | return intra_flag; | |
| 148 | } | ||
| 149 | |||
| 150 | ✗ | static ptrdiff_t lzss_uncompress(MidiVidContext *s, GetByteContext *gb, uint8_t *dst, unsigned int size) | |
| 151 | { | ||
| 152 | ✗ | uint8_t *dst_start = dst; | |
| 153 | ✗ | uint8_t *dst_end = dst + size; | |
| 154 | |||
| 155 | ✗ | for (;bytestream2_get_bytes_left(gb) >= 3;) { | |
| 156 | ✗ | int op = bytestream2_get_le16(gb); | |
| 157 | |||
| 158 | ✗ | for (int i = 0; i < 16; i++) { | |
| 159 | ✗ | if (op & 1) { | |
| 160 | ✗ | int s0 = bytestream2_get_byte(gb); | |
| 161 | ✗ | int s1 = bytestream2_get_byte(gb); | |
| 162 | ✗ | int offset = ((s0 & 0xF0) << 4) | s1; | |
| 163 | ✗ | int length = (s0 & 0xF) + 3; | |
| 164 | |||
| 165 | ✗ | if (dst + length > dst_end || | |
| 166 | ✗ | dst - offset < dst_start) | |
| 167 | ✗ | return AVERROR_INVALIDDATA; | |
| 168 | ✗ | if (offset > 0) { | |
| 169 | ✗ | for (int j = 0; j < length; j++) { | |
| 170 | ✗ | dst[j] = dst[j - offset]; | |
| 171 | } | ||
| 172 | } | ||
| 173 | ✗ | dst += length; | |
| 174 | } else { | ||
| 175 | ✗ | if (dst >= dst_end) | |
| 176 | ✗ | return AVERROR_INVALIDDATA; | |
| 177 | ✗ | *dst++ = bytestream2_get_byte(gb); | |
| 178 | } | ||
| 179 | ✗ | op >>= 1; | |
| 180 | } | ||
| 181 | } | ||
| 182 | |||
| 183 | ✗ | return dst - dst_start; | |
| 184 | } | ||
| 185 | |||
| 186 | ✗ | static int decode_frame(AVCodecContext *avctx, AVFrame *rframe, | |
| 187 | int *got_frame, AVPacket *avpkt) | ||
| 188 | { | ||
| 189 | ✗ | MidiVidContext *s = avctx->priv_data; | |
| 190 | ✗ | GetByteContext *gb = &s->gb; | |
| 191 | ✗ | AVFrame *frame = s->frame; | |
| 192 | int ret, key, uncompressed; | ||
| 193 | |||
| 194 | ✗ | if (avpkt->size <= 13) | |
| 195 | ✗ | return AVERROR_INVALIDDATA; | |
| 196 | |||
| 197 | ✗ | bytestream2_init(gb, avpkt->data, avpkt->size); | |
| 198 | ✗ | bytestream2_skip(gb, 8); | |
| 199 | ✗ | uncompressed = bytestream2_get_le32(gb); | |
| 200 | |||
| 201 | ✗ | if (!uncompressed) { | |
| 202 | ✗ | av_fast_padded_malloc(&s->uncompressed, &s->uncompressed_size, 16LL * (avpkt->size - 12)); | |
| 203 | ✗ | if (!s->uncompressed) | |
| 204 | ✗ | return AVERROR(ENOMEM); | |
| 205 | |||
| 206 | ✗ | ret = lzss_uncompress(s, gb, s->uncompressed, s->uncompressed_size); | |
| 207 | ✗ | if (ret < 0) | |
| 208 | ✗ | return ret; | |
| 209 | ✗ | bytestream2_init(gb, s->uncompressed, ret); | |
| 210 | } | ||
| 211 | |||
| 212 | ✗ | if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0) | |
| 213 | ✗ | return ret; | |
| 214 | |||
| 215 | ✗ | ret = decode_mvdv(s, avctx, frame); | |
| 216 | |||
| 217 | ✗ | if (ret < 0) | |
| 218 | ✗ | return ret; | |
| 219 | ✗ | key = ret; | |
| 220 | |||
| 221 | ✗ | if ((ret = av_frame_ref(rframe, s->frame)) < 0) | |
| 222 | ✗ | return ret; | |
| 223 | |||
| 224 | ✗ | frame->pict_type = key ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P; | |
| 225 | ✗ | if (key) | |
| 226 | ✗ | frame->flags |= AV_FRAME_FLAG_KEY; | |
| 227 | else | ||
| 228 | ✗ | frame->flags &= ~AV_FRAME_FLAG_KEY; | |
| 229 | ✗ | *got_frame = 1; | |
| 230 | |||
| 231 | ✗ | return avpkt->size; | |
| 232 | } | ||
| 233 | |||
| 234 | ✗ | static av_cold int decode_init(AVCodecContext *avctx) | |
| 235 | { | ||
| 236 | ✗ | MidiVidContext *s = avctx->priv_data; | |
| 237 | ✗ | int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx); | |
| 238 | |||
| 239 | ✗ | if (avctx->width & 3 || avctx->height & 3) | |
| 240 | ✗ | ret = AVERROR_INVALIDDATA; | |
| 241 | |||
| 242 | ✗ | if (ret < 0) { | |
| 243 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid image size %dx%d.\n", | |
| 244 | avctx->width, avctx->height); | ||
| 245 | ✗ | return ret; | |
| 246 | } | ||
| 247 | |||
| 248 | ✗ | avctx->pix_fmt = AV_PIX_FMT_YUV444P; | |
| 249 | |||
| 250 | ✗ | s->frame = av_frame_alloc(); | |
| 251 | ✗ | if (!s->frame) | |
| 252 | ✗ | return AVERROR(ENOMEM); | |
| 253 | ✗ | s->skip = av_calloc(avctx->width >> 1, avctx->height >> 1); | |
| 254 | ✗ | if (!s->skip) | |
| 255 | ✗ | return AVERROR(ENOMEM); | |
| 256 | |||
| 257 | ✗ | return 0; | |
| 258 | } | ||
| 259 | |||
| 260 | ✗ | static void decode_flush(AVCodecContext *avctx) | |
| 261 | { | ||
| 262 | ✗ | MidiVidContext *s = avctx->priv_data; | |
| 263 | |||
| 264 | ✗ | av_frame_unref(s->frame); | |
| 265 | ✗ | } | |
| 266 | |||
| 267 | ✗ | static av_cold int decode_close(AVCodecContext *avctx) | |
| 268 | { | ||
| 269 | ✗ | MidiVidContext *s = avctx->priv_data; | |
| 270 | |||
| 271 | ✗ | av_frame_free(&s->frame); | |
| 272 | ✗ | av_freep(&s->uncompressed); | |
| 273 | ✗ | av_freep(&s->skip); | |
| 274 | |||
| 275 | ✗ | return 0; | |
| 276 | } | ||
| 277 | |||
| 278 | const FFCodec ff_mvdv_decoder = { | ||
| 279 | .p.name = "mvdv", | ||
| 280 | CODEC_LONG_NAME("MidiVid VQ"), | ||
| 281 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
| 282 | .p.id = AV_CODEC_ID_MVDV, | ||
| 283 | .priv_data_size = sizeof(MidiVidContext), | ||
| 284 | .init = decode_init, | ||
| 285 | FF_CODEC_DECODE_CB(decode_frame), | ||
| 286 | .flush = decode_flush, | ||
| 287 | .close = decode_close, | ||
| 288 | .p.capabilities = AV_CODEC_CAP_DR1, | ||
| 289 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, | ||
| 290 | }; | ||
| 291 |