| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | * Copyright (C) 2005 Ole André Vadla Ravn?s <oleavr@gmail.com> | ||
| 3 | * Copyright (C) 2008 Ramiro Polla | ||
| 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 <stdint.h> | ||
| 23 | |||
| 24 | #include "libavutil/mem.h" | ||
| 25 | #include "libavutil/mem_internal.h" | ||
| 26 | #include "libavutil/thread.h" | ||
| 27 | |||
| 28 | #include "avcodec.h" | ||
| 29 | #include "blockdsp.h" | ||
| 30 | #include "codec_internal.h" | ||
| 31 | #include "decode.h" | ||
| 32 | #include "get_bits.h" | ||
| 33 | #include "bytestream.h" | ||
| 34 | #include "bswapdsp.h" | ||
| 35 | #include "hpeldsp.h" | ||
| 36 | #include "idctdsp.h" | ||
| 37 | #include "progressframe.h" | ||
| 38 | #include "thread.h" | ||
| 39 | |||
| 40 | #define MIMIC_HEADER_SIZE 20 | ||
| 41 | #define MIMIC_VLC_BITS 11 | ||
| 42 | |||
| 43 | typedef struct MimicContext { | ||
| 44 | AVCodecContext *avctx; | ||
| 45 | |||
| 46 | int num_vblocks[3]; | ||
| 47 | int num_hblocks[3]; | ||
| 48 | |||
| 49 | void *swap_buf; | ||
| 50 | int swap_buf_size; | ||
| 51 | |||
| 52 | int cur_index; | ||
| 53 | int prev_index; | ||
| 54 | |||
| 55 | ProgressFrame frames[16]; | ||
| 56 | |||
| 57 | DECLARE_ALIGNED(32, int16_t, dct_block)[64]; | ||
| 58 | |||
| 59 | GetBitContext gb; | ||
| 60 | uint8_t permutated_scantable[64]; | ||
| 61 | BlockDSPContext bdsp; | ||
| 62 | BswapDSPContext bbdsp; | ||
| 63 | HpelDSPContext hdsp; | ||
| 64 | IDCTDSPContext idsp; | ||
| 65 | |||
| 66 | /* Kept in the context so multithreading can have a constant to read from */ | ||
| 67 | int next_cur_index; | ||
| 68 | int next_prev_index; | ||
| 69 | } MimicContext; | ||
| 70 | |||
| 71 | static VLCElem block_vlc[4368]; | ||
| 72 | |||
| 73 | static const uint8_t huffsyms[] = { | ||
| 74 | 0x10, 0x20, 0x30, 0x00, 0x11, 0x40, 0x50, 0x12, 0x13, 0x21, 0x31, 0x60, | ||
| 75 | 0x14, 0x15, 0x16, 0x22, 0x41, 0x17, 0x18, 0x23, 0x24, 0x25, 0x32, 0x42, | ||
| 76 | 0x51, 0x61, 0x70, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x26, 0x27, | ||
| 77 | 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x33, 0x34, 0x35, 0x36, 0x37, | ||
| 78 | 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x43, 0x44, 0x45, 0x46, 0x47, | ||
| 79 | 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x52, 0x53, 0x54, 0x55, 0x56, | ||
| 80 | 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x62, 0x63, 0x64, 0x65, | ||
| 81 | 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x71, 0x72, 0x73, | ||
| 82 | 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, | ||
| 83 | }; | ||
| 84 | |||
| 85 | static const uint8_t huffbits[] = { | ||
| 86 | 2, 2, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, | ||
| 87 | 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, | ||
| 88 | 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, | ||
| 89 | 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, | ||
| 90 | 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26, | ||
| 91 | 26, 26, 27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30, | ||
| 92 | }; | ||
| 93 | |||
| 94 | static const uint8_t col_zag[64] = { | ||
| 95 | 0, 8, 1, 2, 9, 16, 24, 17, | ||
| 96 | 10, 3, 4, 11, 18, 25, 32, 40, | ||
| 97 | 33, 26, 19, 12, 5, 6, 13, 20, | ||
| 98 | 27, 34, 41, 48, 56, 49, 42, 35, | ||
| 99 | 28, 21, 14, 7, 15, 22, 29, 36, | ||
| 100 | 43, 50, 57, 58, 51, 44, 37, 30, | ||
| 101 | 23, 31, 38, 45, 52, 59, 39, 46, | ||
| 102 | 53, 60, 61, 54, 47, 55, 62, 63, | ||
| 103 | }; | ||
| 104 | |||
| 105 | 2 | static av_cold int mimic_decode_end(AVCodecContext *avctx) | |
| 106 | { | ||
| 107 | 2 | MimicContext *ctx = avctx->priv_data; | |
| 108 | |||
| 109 | 2 | av_freep(&ctx->swap_buf); | |
| 110 | 2 | ctx->swap_buf_size = 0; | |
| 111 | |||
| 112 |
2/2✓ Branch 0 taken 32 times.
✓ Branch 1 taken 2 times.
|
34 | for (int i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) |
| 113 | 32 | ff_progress_frame_unref(&ctx->frames[i]); | |
| 114 | |||
| 115 | 2 | return 0; | |
| 116 | } | ||
| 117 | |||
| 118 | 1 | static av_cold void mimic_init_static(void) | |
| 119 | { | ||
| 120 | 1 | VLC_INIT_STATIC_TABLE_FROM_LENGTHS(block_vlc, MIMIC_VLC_BITS, | |
| 121 | FF_ARRAY_ELEMS(huffbits), | ||
| 122 | huffbits, 1, huffsyms, 1, 1, 0, 0); | ||
| 123 | 1 | } | |
| 124 | |||
| 125 | 2 | static av_cold int mimic_decode_init(AVCodecContext *avctx) | |
| 126 | { | ||
| 127 | static AVOnce init_static_once = AV_ONCE_INIT; | ||
| 128 | 2 | MimicContext *ctx = avctx->priv_data; | |
| 129 | |||
| 130 | 2 | ctx->prev_index = 0; | |
| 131 | 2 | ctx->cur_index = 15; | |
| 132 | |||
| 133 | 2 | ff_blockdsp_init(&ctx->bdsp); | |
| 134 | 2 | ff_bswapdsp_init(&ctx->bbdsp); | |
| 135 | 2 | ff_hpeldsp_init(&ctx->hdsp, avctx->flags); | |
| 136 | 2 | ff_idctdsp_init(&ctx->idsp, avctx); | |
| 137 | 2 | ff_permute_scantable(ctx->permutated_scantable, col_zag, ctx->idsp.idct_permutation); | |
| 138 | |||
| 139 | 2 | ff_thread_once(&init_static_once, mimic_init_static); | |
| 140 | |||
| 141 | 2 | return 0; | |
| 142 | } | ||
| 143 | |||
| 144 | #if HAVE_THREADS | ||
| 145 | ✗ | static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from) | |
| 146 | { | ||
| 147 | ✗ | MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data; | |
| 148 | |||
| 149 | ✗ | if (avctx == avctx_from) | |
| 150 | ✗ | return 0; | |
| 151 | |||
| 152 | ✗ | dst->cur_index = src->next_cur_index; | |
| 153 | ✗ | dst->prev_index = src->next_prev_index; | |
| 154 | |||
| 155 | ✗ | for (int i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) { | |
| 156 | ✗ | ff_progress_frame_unref(&dst->frames[i]); | |
| 157 | ✗ | if (i != src->next_cur_index && src->frames[i].f) | |
| 158 | ✗ | ff_progress_frame_ref(&dst->frames[i], &src->frames[i]); | |
| 159 | } | ||
| 160 | |||
| 161 | ✗ | return 0; | |
| 162 | } | ||
| 163 | #endif | ||
| 164 | |||
| 165 | static const int8_t vlcdec_lookup[9][64] = { | ||
| 166 | { 0, }, | ||
| 167 | { -1, 1, }, | ||
| 168 | { -3, 3, -2, 2, }, | ||
| 169 | { -7, 7, -6, 6, -5, 5, -4, 4, }, | ||
| 170 | { -15, 15, -14, 14, -13, 13, -12, 12, | ||
| 171 | -11, 11, -10, 10, -9, 9, -8, 8, }, | ||
| 172 | { -31, 31, -30, 30, -29, 29, -28, 28, | ||
| 173 | -27, 27, -26, 26, -25, 25, -24, 24, | ||
| 174 | -23, 23, -22, 22, -21, 21, -20, 20, | ||
| 175 | -19, 19, -18, 18, -17, 17, -16, 16, }, | ||
| 176 | { -63, 63, -62, 62, -61, 61, -60, 60, | ||
| 177 | -59, 59, -58, 58, -57, 57, -56, 56, | ||
| 178 | -55, 55, -54, 54, -53, 53, -52, 52, | ||
| 179 | -51, 51, -50, 50, -49, 49, -48, 48, | ||
| 180 | -47, 47, -46, 46, -45, 45, -44, 44, | ||
| 181 | -43, 43, -42, 42, -41, 41, -40, 40, | ||
| 182 | -39, 39, -38, 38, -37, 37, -36, 36, | ||
| 183 | -35, 35, -34, 34, -33, 33, -32, 32, }, | ||
| 184 | { -127, 127, -126, 126, -125, 125, -124, 124, | ||
| 185 | -123, 123, -122, 122, -121, 121, -120, 120, | ||
| 186 | -119, 119, -118, 118, -117, 117, -116, 116, | ||
| 187 | -115, 115, -114, 114, -113, 113, -112, 112, | ||
| 188 | -111, 111, -110, 110, -109, 109, -108, 108, | ||
| 189 | -107, 107, -106, 106, -105, 105, -104, 104, | ||
| 190 | -103, 103, -102, 102, -101, 101, -100, 100, | ||
| 191 | -99, 99, -98, 98, -97, 97, -96, 96, }, | ||
| 192 | { -95, 95, -94, 94, -93, 93, -92, 92, | ||
| 193 | -91, 91, -90, 90, -89, 89, -88, 88, | ||
| 194 | -87, 87, -86, 86, -85, 85, -84, 84, | ||
| 195 | -83, 83, -82, 82, -81, 81, -80, 80, | ||
| 196 | -79, 79, -78, 78, -77, 77, -76, 76, | ||
| 197 | -75, 75, -74, 74, -73, 73, -72, 72, | ||
| 198 | -71, 71, -70, 70, -69, 69, -68, 68, | ||
| 199 | -67, 67, -66, 66, -65, 65, -64, 64, }, | ||
| 200 | }; | ||
| 201 | |||
| 202 | 44548 | static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale) | |
| 203 | { | ||
| 204 | 44548 | int16_t *block = ctx->dct_block; | |
| 205 | unsigned int pos; | ||
| 206 | |||
| 207 | 44548 | ctx->bdsp.clear_block(block); | |
| 208 | |||
| 209 | 44548 | block[0] = get_bits(&ctx->gb, 8) << 3; | |
| 210 | |||
| 211 |
2/2✓ Branch 0 taken 302169 times.
✓ Branch 1 taken 2724 times.
|
304893 | for (pos = 1; pos < num_coeffs; pos++) { |
| 212 | uint32_t vlc, num_bits; | ||
| 213 | int value; | ||
| 214 | int coeff; | ||
| 215 | |||
| 216 | 302169 | vlc = get_vlc2(&ctx->gb, block_vlc, MIMIC_VLC_BITS, 3); | |
| 217 |
2/2✓ Branch 0 taken 41824 times.
✓ Branch 1 taken 260345 times.
|
302169 | if (!vlc) /* end-of-block code */ |
| 218 | 41824 | return 0; | |
| 219 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 260345 times.
|
260345 | if (vlc == -1) |
| 220 | ✗ | return AVERROR_INVALIDDATA; | |
| 221 | |||
| 222 | /* pos_add and num_bits are coded in the vlc code */ | ||
| 223 | 260345 | pos += vlc & 15; // pos_add | |
| 224 | 260345 | num_bits = vlc >> 4; // num_bits | |
| 225 | |||
| 226 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 260345 times.
|
260345 | if (pos >= 64) |
| 227 | ✗ | return AVERROR_INVALIDDATA; | |
| 228 | |||
| 229 | 260345 | value = get_bits(&ctx->gb, num_bits); | |
| 230 | |||
| 231 | /* FFmpeg's IDCT behaves somewhat different from the original code, so | ||
| 232 | * a factor of 4 was added to the input */ | ||
| 233 | |||
| 234 | 260345 | coeff = ((int8_t*)vlcdec_lookup[num_bits])[value]; | |
| 235 |
2/2✓ Branch 0 taken 50048 times.
✓ Branch 1 taken 210297 times.
|
260345 | if (pos < 3) |
| 236 | 50048 | coeff *= 16; | |
| 237 | else /* TODO Use >> 10 instead of / 1001 */ | ||
| 238 | 210297 | coeff = (coeff * qscale) / 1001; | |
| 239 | |||
| 240 | 260345 | block[ctx->permutated_scantable[pos]] = coeff; | |
| 241 | } | ||
| 242 | |||
| 243 | 2724 | return 0; | |
| 244 | } | ||
| 245 | |||
| 246 | 77 | static int decode(MimicContext *ctx, int quality, int num_coeffs, | |
| 247 | int is_iframe) | ||
| 248 | { | ||
| 249 | 77 | int ret, y, x, plane, cur_row = 0; | |
| 250 | |||
| 251 |
2/2✓ Branch 0 taken 231 times.
✓ Branch 1 taken 77 times.
|
308 | for (plane = 0; plane < 3; plane++) { |
| 252 | 231 | const int is_chroma = !!plane; | |
| 253 |
2/2✓ Branch 0 taken 154 times.
✓ Branch 1 taken 77 times.
|
231 | const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000, |
| 254 | 10000) << 2; | ||
| 255 | 231 | const int stride = ctx->frames[ctx->cur_index ].f->linesize[plane]; | |
| 256 | 231 | uint8_t *dst = ctx->frames[ctx->cur_index ].f->data[plane]; | |
| 257 | /* src is unused for I frames; set to avoid UB pointer arithmetic. */ | ||
| 258 |
2/2✓ Branch 0 taken 222 times.
✓ Branch 1 taken 9 times.
|
231 | const uint8_t *src = is_iframe ? dst : ctx->frames[ctx->prev_index].f->data[plane]; |
| 259 | |||
| 260 |
2/2✓ Branch 0 taken 4620 times.
✓ Branch 1 taken 231 times.
|
4851 | for (y = 0; y < ctx->num_vblocks[plane]; y++) { |
| 261 |
2/2✓ Branch 0 taken 138600 times.
✓ Branch 1 taken 4620 times.
|
143220 | for (x = 0; x < ctx->num_hblocks[plane]; x++) { |
| 262 | /* Check for a change condition in the current block. | ||
| 263 | * - iframes always change. | ||
| 264 | * - Luma plane changes on get_bits1 == 0 | ||
| 265 | * - Chroma planes change on get_bits1 == 1 */ | ||
| 266 |
4/4✓ Branch 0 taken 133200 times.
✓ Branch 1 taken 5400 times.
✓ Branch 3 taken 45091 times.
✓ Branch 4 taken 88109 times.
|
138600 | if (is_iframe || get_bits1(&ctx->gb) == is_chroma) { |
| 267 | /* Luma planes may use a backreference from the 15 last | ||
| 268 | * frames preceding the previous. (get_bits1 == 1) | ||
| 269 | * Chroma planes don't use backreferences. */ | ||
| 270 |
6/6✓ Branch 0 taken 37390 times.
✓ Branch 1 taken 13101 times.
✓ Branch 2 taken 33790 times.
✓ Branch 3 taken 3600 times.
✓ Branch 5 taken 27847 times.
✓ Branch 6 taken 5943 times.
|
50491 | if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) { |
| 271 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 44548 times.
|
44548 | if ((ret = vlc_decode_block(ctx, num_coeffs, |
| 272 | qscale)) < 0) { | ||
| 273 | ✗ | av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding " | |
| 274 | "block.\n"); | ||
| 275 | ✗ | return ret; | |
| 276 | } | ||
| 277 | 44548 | ctx->idsp.idct_put(dst, stride, ctx->dct_block); | |
| 278 | } else { | ||
| 279 | 5943 | unsigned int backref = get_bits(&ctx->gb, 4); | |
| 280 | 5943 | int index = (ctx->cur_index + backref) & 15; | |
| 281 | |||
| 282 |
2/4✓ Branch 0 taken 5943 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5943 times.
✗ Branch 3 not taken.
|
11886 | if (index != ctx->cur_index && ctx->frames[index].f) { |
| 283 | 5943 | const uint8_t *p = ctx->frames[index].f->data[0]; | |
| 284 | 5943 | ff_progress_frame_await(&ctx->frames[index], cur_row); | |
| 285 | 5943 | p += src - | |
| 286 | 5943 | ctx->frames[ctx->prev_index].f->data[plane]; | |
| 287 | 5943 | ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8); | |
| 288 | } else { | ||
| 289 | ✗ | av_log(ctx->avctx, AV_LOG_ERROR, | |
| 290 | "No such backreference! Buggy sample.\n"); | ||
| 291 | } | ||
| 292 | } | ||
| 293 | } else { | ||
| 294 | 88109 | ff_progress_frame_await(&ctx->frames[ctx->prev_index], cur_row); | |
| 295 | 88109 | ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8); | |
| 296 | } | ||
| 297 | 138600 | src += 8; | |
| 298 | 138600 | dst += 8; | |
| 299 | } | ||
| 300 | 4620 | src += (stride - ctx->num_hblocks[plane]) << 3; | |
| 301 | 4620 | dst += (stride - ctx->num_hblocks[plane]) << 3; | |
| 302 | |||
| 303 | 4620 | ff_progress_frame_report(&ctx->frames[ctx->cur_index], cur_row++); | |
| 304 | } | ||
| 305 | } | ||
| 306 | |||
| 307 | 77 | return 0; | |
| 308 | } | ||
| 309 | |||
| 310 | /** | ||
| 311 | * Flip the buffer upside-down and put it in the YVU order to revert the | ||
| 312 | * way Mimic encodes frames. | ||
| 313 | */ | ||
| 314 | 77 | static void flip_swap_frame(AVFrame *f) | |
| 315 | { | ||
| 316 | int i; | ||
| 317 | 77 | uint8_t *data_1 = f->data[1]; | |
| 318 | 77 | f->data[0] = f->data[0] + ( f->height - 1) * f->linesize[0]; | |
| 319 | 77 | f->data[1] = f->data[2] + ((f->height >> 1) - 1) * f->linesize[2]; | |
| 320 | 77 | f->data[2] = data_1 + ((f->height >> 1) - 1) * f->linesize[1]; | |
| 321 |
2/2✓ Branch 0 taken 231 times.
✓ Branch 1 taken 77 times.
|
308 | for (i = 0; i < 3; i++) |
| 322 | 231 | f->linesize[i] *= -1; | |
| 323 | 77 | } | |
| 324 | |||
| 325 | 77 | static int mimic_decode_frame(AVCodecContext *avctx, AVFrame *rframe, | |
| 326 | int *got_frame, AVPacket *avpkt) | ||
| 327 | { | ||
| 328 | 77 | const uint8_t *buf = avpkt->data; | |
| 329 | 77 | int buf_size = avpkt->size; | |
| 330 | 77 | int swap_buf_size = buf_size - MIMIC_HEADER_SIZE; | |
| 331 | 77 | MimicContext *ctx = avctx->priv_data; | |
| 332 | GetByteContext gb; | ||
| 333 | int is_pframe; | ||
| 334 | int width, height; | ||
| 335 | int quality, num_coeffs; | ||
| 336 | int res; | ||
| 337 | |||
| 338 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 77 times.
|
77 | if (buf_size <= MIMIC_HEADER_SIZE) { |
| 339 | ✗ | av_log(avctx, AV_LOG_ERROR, "insufficient data\n"); | |
| 340 | ✗ | return AVERROR_INVALIDDATA; | |
| 341 | } | ||
| 342 | |||
| 343 | 77 | bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE); | |
| 344 | 77 | bytestream2_skip(&gb, 2); /* some constant (always 256) */ | |
| 345 | 77 | quality = bytestream2_get_le16u(&gb); | |
| 346 | 77 | width = bytestream2_get_le16u(&gb); | |
| 347 | 77 | height = bytestream2_get_le16u(&gb); | |
| 348 | 77 | bytestream2_skip(&gb, 4); /* some constant */ | |
| 349 | 77 | is_pframe = bytestream2_get_le32u(&gb); | |
| 350 | 77 | num_coeffs = bytestream2_get_byteu(&gb); | |
| 351 | 77 | bytestream2_skip(&gb, 3); /* some constant */ | |
| 352 | |||
| 353 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 75 times.
|
77 | if (!ctx->avctx) { |
| 354 | int i; | ||
| 355 | |||
| 356 |
2/6✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
|
2 | if (!(width == 160 && height == 120) && |
| 357 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | !(width == 320 && height == 240)) { |
| 358 | ✗ | av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n"); | |
| 359 | ✗ | return AVERROR_INVALIDDATA; | |
| 360 | } | ||
| 361 | |||
| 362 | 2 | res = ff_set_dimensions(avctx, width, height); | |
| 363 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (res < 0) |
| 364 | ✗ | return res; | |
| 365 | |||
| 366 | 2 | ctx->avctx = avctx; | |
| 367 | 2 | avctx->pix_fmt = AV_PIX_FMT_YUV420P; | |
| 368 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2 times.
|
8 | for (i = 0; i < 3; i++) { |
| 369 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.
|
6 | ctx->num_vblocks[i] = AV_CEIL_RSHIFT(height, 3 + !!i); |
| 370 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.
|
6 | ctx->num_hblocks[i] = width >> (3 + !!i); |
| 371 | } | ||
| 372 |
2/4✓ Branch 0 taken 75 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 75 times.
|
75 | } else if (width != ctx->avctx->width || height != ctx->avctx->height) { |
| 373 | ✗ | avpriv_request_sample(avctx, "Resolution changing"); | |
| 374 | ✗ | return AVERROR_PATCHWELCOME; | |
| 375 | } | ||
| 376 | |||
| 377 |
3/4✓ Branch 0 taken 74 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 74 times.
|
77 | if (is_pframe && !ctx->frames[ctx->prev_index].f) { |
| 378 | ✗ | av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n"); | |
| 379 | ✗ | return AVERROR_INVALIDDATA; | |
| 380 | } | ||
| 381 | |||
| 382 | 77 | ff_progress_frame_unref(&ctx->frames[ctx->cur_index]); | |
| 383 | 77 | res = ff_progress_frame_get_buffer(avctx, &ctx->frames[ctx->cur_index], | |
| 384 | AV_GET_BUFFER_FLAG_REF); | ||
| 385 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 77 times.
|
77 | if (res < 0) |
| 386 | ✗ | return res; | |
| 387 |
2/2✓ Branch 0 taken 74 times.
✓ Branch 1 taken 3 times.
|
77 | ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P : |
| 388 | AV_PICTURE_TYPE_I; | ||
| 389 | |||
| 390 | 77 | ctx->next_prev_index = ctx->cur_index; | |
| 391 | 77 | ctx->next_cur_index = (ctx->cur_index - 1) & 15; | |
| 392 | |||
| 393 | 77 | ff_thread_finish_setup(avctx); | |
| 394 | |||
| 395 | 77 | av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size); | |
| 396 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 77 times.
|
77 | if (!ctx->swap_buf) |
| 397 | ✗ | return AVERROR(ENOMEM); | |
| 398 | |||
| 399 | 77 | ctx->bbdsp.bswap_buf(ctx->swap_buf, | |
| 400 | 77 | (const uint32_t *) (buf + MIMIC_HEADER_SIZE), | |
| 401 | swap_buf_size >> 2); | ||
| 402 | 77 | init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3); | |
| 403 | |||
| 404 | 77 | res = decode(ctx, quality, num_coeffs, !is_pframe); | |
| 405 | 77 | ff_progress_frame_report(&ctx->frames[ctx->cur_index], INT_MAX); | |
| 406 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 77 times.
|
77 | if (res < 0) { |
| 407 | ✗ | if (!(avctx->active_thread_type & FF_THREAD_FRAME)) | |
| 408 | ✗ | ff_progress_frame_unref(&ctx->frames[ctx->cur_index]); | |
| 409 | ✗ | return res; | |
| 410 | } | ||
| 411 | |||
| 412 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 77 times.
|
77 | if ((res = av_frame_ref(rframe, ctx->frames[ctx->cur_index].f)) < 0) |
| 413 | ✗ | return res; | |
| 414 | 77 | *got_frame = 1; | |
| 415 | |||
| 416 | 77 | flip_swap_frame(rframe); | |
| 417 | |||
| 418 | 77 | ctx->prev_index = ctx->next_prev_index; | |
| 419 | 77 | ctx->cur_index = ctx->next_cur_index; | |
| 420 | |||
| 421 | 77 | return buf_size; | |
| 422 | } | ||
| 423 | |||
| 424 | const FFCodec ff_mimic_decoder = { | ||
| 425 | .p.name = "mimic", | ||
| 426 | CODEC_LONG_NAME("Mimic"), | ||
| 427 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
| 428 | .p.id = AV_CODEC_ID_MIMIC, | ||
| 429 | .priv_data_size = sizeof(MimicContext), | ||
| 430 | .init = mimic_decode_init, | ||
| 431 | .close = mimic_decode_end, | ||
| 432 | FF_CODEC_DECODE_CB(mimic_decode_frame), | ||
| 433 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, | ||
| 434 | UPDATE_THREAD_CONTEXT(mimic_decode_update_thread_context), | ||
| 435 | .caps_internal = FF_CODEC_CAP_USES_PROGRESSFRAMES | | ||
| 436 | FF_CODEC_CAP_INIT_CLEANUP, | ||
| 437 | }; | ||
| 438 |