LCOV - code coverage report
Current view: top level - libavcodec - truemotion2.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 479 567 84.5 %
Date: 2018-05-20 11:54:08 Functions: 22 22 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Duck/ON2 TrueMotion 2 Decoder
       3             :  * Copyright (c) 2005 Konstantin Shishkov
       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             : /**
      23             :  * @file
      24             :  * Duck TrueMotion2 decoder.
      25             :  */
      26             : 
      27             : #include <inttypes.h>
      28             : 
      29             : #include "avcodec.h"
      30             : #include "bswapdsp.h"
      31             : #include "bytestream.h"
      32             : #include "get_bits.h"
      33             : #include "internal.h"
      34             : 
      35             : #define TM2_ESCAPE 0x80000000
      36             : #define TM2_DELTAS 64
      37             : 
      38             : /* Huffman-coded streams of different types of blocks */
      39             : enum TM2_STREAMS {
      40             :     TM2_C_HI = 0,
      41             :     TM2_C_LO,
      42             :     TM2_L_HI,
      43             :     TM2_L_LO,
      44             :     TM2_UPD,
      45             :     TM2_MOT,
      46             :     TM2_TYPE,
      47             :     TM2_NUM_STREAMS
      48             : };
      49             : 
      50             : /* Block types */
      51             : enum TM2_BLOCKS {
      52             :     TM2_HI_RES = 0,
      53             :     TM2_MED_RES,
      54             :     TM2_LOW_RES,
      55             :     TM2_NULL_RES,
      56             :     TM2_UPDATE,
      57             :     TM2_STILL,
      58             :     TM2_MOTION
      59             : };
      60             : 
      61             : typedef struct TM2Context {
      62             :     AVCodecContext *avctx;
      63             :     AVFrame *pic;
      64             : 
      65             :     GetBitContext gb;
      66             :     int error;
      67             :     BswapDSPContext bdsp;
      68             : 
      69             :     uint8_t *buffer;
      70             :     int buffer_size;
      71             : 
      72             :     /* TM2 streams */
      73             :     int *tokens[TM2_NUM_STREAMS];
      74             :     int tok_lens[TM2_NUM_STREAMS];
      75             :     int tok_ptrs[TM2_NUM_STREAMS];
      76             :     int deltas[TM2_NUM_STREAMS][TM2_DELTAS];
      77             :     /* for blocks decoding */
      78             :     int D[4];
      79             :     int CD[4];
      80             :     int *last;
      81             :     int *clast;
      82             : 
      83             :     /* data for current and previous frame */
      84             :     int *Y1_base, *U1_base, *V1_base, *Y2_base, *U2_base, *V2_base;
      85             :     int *Y1, *U1, *V1, *Y2, *U2, *V2;
      86             :     int y_stride, uv_stride;
      87             :     int cur;
      88             : } TM2Context;
      89             : 
      90             : /**
      91             : * Huffman codes for each of streams
      92             : */
      93             : typedef struct TM2Codes {
      94             :     VLC vlc; ///< table for FFmpeg bitstream reader
      95             :     int bits;
      96             :     int *recode; ///< table for converting from code indexes to values
      97             :     int length;
      98             : } TM2Codes;
      99             : 
     100             : /**
     101             : * structure for gathering Huffman codes information
     102             : */
     103             : typedef struct TM2Huff {
     104             :     int val_bits; ///< length of literal
     105             :     int max_bits; ///< maximum length of code
     106             :     int min_bits; ///< minimum length of code
     107             :     int nodes; ///< total number of nodes in tree
     108             :     int num; ///< current number filled
     109             :     int max_num; ///< total number of codes
     110             :     int *nums; ///< literals
     111             :     uint32_t *bits; ///< codes
     112             :     int *lens; ///< codelengths
     113             : } TM2Huff;
     114             : 
     115        3148 : static int tm2_read_tree(TM2Context *ctx, uint32_t prefix, int length, TM2Huff *huff)
     116             : {
     117             :     int ret;
     118        3148 :     if (length > huff->max_bits) {
     119           0 :         av_log(ctx->avctx, AV_LOG_ERROR, "Tree exceeded its given depth (%i)\n",
     120             :                huff->max_bits);
     121           0 :         return AVERROR_INVALIDDATA;
     122             :     }
     123             : 
     124        3148 :     if (!get_bits1(&ctx->gb)) { /* literal */
     125        1670 :         if (length == 0) {
     126           3 :             length = 1;
     127             :         }
     128        1670 :         if (huff->num >= huff->max_num) {
     129           0 :             av_log(ctx->avctx, AV_LOG_DEBUG, "Too many literals\n");
     130           0 :             return AVERROR_INVALIDDATA;
     131             :         }
     132        1670 :         huff->nums[huff->num] = get_bits_long(&ctx->gb, huff->val_bits);
     133        1670 :         huff->bits[huff->num] = prefix;
     134        1670 :         huff->lens[huff->num] = length;
     135        1670 :         huff->num++;
     136        1670 :         return 0;
     137             :     } else { /* non-terminal node */
     138        1478 :         if ((ret = tm2_read_tree(ctx, prefix << 1, length + 1, huff)) < 0)
     139           0 :             return ret;
     140        1478 :         if ((ret = tm2_read_tree(ctx, (prefix << 1) | 1, length + 1, huff)) < 0)
     141           0 :             return ret;
     142             :     }
     143        1478 :     return 0;
     144             : }
     145             : 
     146         192 : static int tm2_build_huff_table(TM2Context *ctx, TM2Codes *code)
     147             : {
     148             :     TM2Huff huff;
     149         192 :     int res = 0;
     150             : 
     151         192 :     huff.val_bits = get_bits(&ctx->gb, 5);
     152         192 :     huff.max_bits = get_bits(&ctx->gb, 5);
     153         192 :     huff.min_bits = get_bits(&ctx->gb, 5);
     154         192 :     huff.nodes    = get_bits_long(&ctx->gb, 17);
     155         192 :     huff.num      = 0;
     156             : 
     157             :     /* check for correct codes parameters */
     158         384 :     if ((huff.val_bits < 1) || (huff.val_bits > 32) ||
     159         384 :         (huff.max_bits < 0) || (huff.max_bits > 25)) {
     160           0 :         av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect tree parameters - literal "
     161             :                "length: %i, max code length: %i\n", huff.val_bits, huff.max_bits);
     162           0 :         return AVERROR_INVALIDDATA;
     163             :     }
     164         192 :     if ((huff.nodes <= 0) || (huff.nodes > 0x10000)) {
     165           0 :         av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect number of Huffman tree "
     166             :                "nodes: %i\n", huff.nodes);
     167           0 :         return AVERROR_INVALIDDATA;
     168             :     }
     169             :     /* one-node tree */
     170         192 :     if (huff.max_bits == 0)
     171           3 :         huff.max_bits = 1;
     172             : 
     173             :     /* allocate space for codes - it is exactly ceil(nodes / 2) entries */
     174         192 :     huff.max_num = (huff.nodes + 1) >> 1;
     175         192 :     huff.nums    = av_calloc(huff.max_num, sizeof(int));
     176         192 :     huff.bits    = av_calloc(huff.max_num, sizeof(uint32_t));
     177         192 :     huff.lens    = av_calloc(huff.max_num, sizeof(int));
     178             : 
     179         192 :     if (!huff.nums || !huff.bits || !huff.lens) {
     180           0 :         res = AVERROR(ENOMEM);
     181           0 :         goto out;
     182             :     }
     183             : 
     184         192 :     res = tm2_read_tree(ctx, 0, 0, &huff);
     185             : 
     186         192 :     if (huff.num != huff.max_num) {
     187           0 :         av_log(ctx->avctx, AV_LOG_ERROR, "Got less codes than expected: %i of %i\n",
     188             :                huff.num, huff.max_num);
     189           0 :         res = AVERROR_INVALIDDATA;
     190             :     }
     191             : 
     192             :     /* convert codes to vlc_table */
     193         192 :     if (res >= 0) {
     194             :         int i;
     195             : 
     196         192 :         res = init_vlc(&code->vlc, huff.max_bits, huff.max_num,
     197             :                        huff.lens, sizeof(int), sizeof(int),
     198             :                        huff.bits, sizeof(uint32_t), sizeof(uint32_t), 0);
     199         192 :         if (res < 0)
     200           0 :             av_log(ctx->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
     201             :         else {
     202         192 :             code->bits = huff.max_bits;
     203         192 :             code->length = huff.max_num;
     204         192 :             code->recode = av_malloc_array(code->length, sizeof(int));
     205         192 :             if (!code->recode) {
     206           0 :                 res = AVERROR(ENOMEM);
     207           0 :                 goto out;
     208             :             }
     209        1862 :             for (i = 0; i < code->length; i++)
     210        1670 :                 code->recode[i] = huff.nums[i];
     211             :         }
     212             :     }
     213             : 
     214         192 : out:
     215             :     /* free allocated memory */
     216         192 :     av_free(huff.nums);
     217         192 :     av_free(huff.bits);
     218         192 :     av_free(huff.lens);
     219             : 
     220         192 :     return res;
     221             : }
     222             : 
     223         192 : static void tm2_free_codes(TM2Codes *code)
     224             : {
     225         192 :     av_free(code->recode);
     226         192 :     if (code->vlc.table)
     227         192 :         ff_free_vlc(&code->vlc);
     228         192 : }
     229             : 
     230     2353240 : static inline int tm2_get_token(GetBitContext *gb, TM2Codes *code)
     231             : {
     232             :     int val;
     233     2353240 :     val = get_vlc2(gb, code->vlc.table, code->bits, 1);
     234     2353240 :     if(val<0)
     235           0 :         return -1;
     236     2353240 :     return code->recode[val];
     237             : }
     238             : 
     239             : #define TM2_OLD_HEADER_MAGIC 0x00000100
     240             : #define TM2_NEW_HEADER_MAGIC 0x00000101
     241             : 
     242          30 : static inline int tm2_read_header(TM2Context *ctx, const uint8_t *buf)
     243             : {
     244          30 :     uint32_t magic = AV_RL32(buf);
     245             : 
     246          30 :     switch (magic) {
     247           0 :     case TM2_OLD_HEADER_MAGIC:
     248           0 :         avpriv_request_sample(ctx->avctx, "Old TM2 header");
     249           0 :         return 0;
     250          30 :     case TM2_NEW_HEADER_MAGIC:
     251          30 :         return 0;
     252           0 :     default:
     253           0 :         av_log(ctx->avctx, AV_LOG_ERROR, "Not a TM2 header: 0x%08"PRIX32"\n",
     254             :                magic);
     255           0 :         return AVERROR_INVALIDDATA;
     256             :     }
     257             : }
     258             : 
     259          29 : static int tm2_read_deltas(TM2Context *ctx, int stream_id)
     260             : {
     261             :     int d, mb;
     262             :     int i, v;
     263             : 
     264          29 :     d  = get_bits(&ctx->gb, 9);
     265          29 :     mb = get_bits(&ctx->gb, 5);
     266             : 
     267             :     av_assert2(mb < 32);
     268          29 :     if ((d < 1) || (d > TM2_DELTAS) || (mb < 1)) {
     269           0 :         av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect delta table: %i deltas x %i bits\n", d, mb);
     270           0 :         return AVERROR_INVALIDDATA;
     271             :     }
     272             : 
     273         594 :     for (i = 0; i < d; i++) {
     274         565 :         v = get_bits_long(&ctx->gb, mb);
     275         565 :         if (v & (1 << (mb - 1)))
     276         270 :             ctx->deltas[stream_id][i] = v - (1U << mb);
     277             :         else
     278         295 :             ctx->deltas[stream_id][i] = v;
     279             :     }
     280        1320 :     for (; i < TM2_DELTAS; i++)
     281        1291 :         ctx->deltas[stream_id][i] = 0;
     282             : 
     283          29 :     return 0;
     284             : }
     285             : 
     286         210 : static int tm2_read_stream(TM2Context *ctx, const uint8_t *buf, int stream_id, int buf_size)
     287             : {
     288             :     int i, ret;
     289         210 :     int skip = 0;
     290             :     int len, toks, pos;
     291             :     TM2Codes codes;
     292             :     GetByteContext gb;
     293             : 
     294         210 :     if (buf_size < 4) {
     295           0 :         av_log(ctx->avctx, AV_LOG_ERROR, "not enough space for len left\n");
     296           0 :         return AVERROR_INVALIDDATA;
     297             :     }
     298             : 
     299             :     /* get stream length in dwords */
     300         210 :     bytestream2_init(&gb, buf, buf_size);
     301         210 :     len  = bytestream2_get_be32(&gb);
     302             : 
     303         210 :     if (len == 0)
     304          18 :         return 4;
     305             : 
     306         192 :     if (len >= INT_MAX / 4 - 1 || len < 0 || len * 4 + 4 > buf_size) {
     307           0 :         av_log(ctx->avctx, AV_LOG_ERROR, "Error, invalid stream size.\n");
     308           0 :         return AVERROR_INVALIDDATA;
     309             :     }
     310         192 :     skip = len * 4 + 4;
     311             : 
     312         192 :     toks = bytestream2_get_be32(&gb);
     313         192 :     if (toks & 1) {
     314         162 :         len = bytestream2_get_be32(&gb);
     315         162 :         if (len == TM2_ESCAPE) {
     316           5 :             len = bytestream2_get_be32(&gb);
     317             :         }
     318         162 :         if (len > 0) {
     319          29 :             pos = bytestream2_tell(&gb);
     320          29 :             if (skip <= pos)
     321           0 :                 return AVERROR_INVALIDDATA;
     322          29 :             init_get_bits(&ctx->gb, buf + pos, (skip - pos) * 8);
     323          29 :             if ((ret = tm2_read_deltas(ctx, stream_id)) < 0)
     324           0 :                 return ret;
     325          29 :             bytestream2_skip(&gb, ((get_bits_count(&ctx->gb) + 31) >> 5) << 2);
     326             :         }
     327             :     }
     328             :     /* skip unused fields */
     329         192 :     len = bytestream2_get_be32(&gb);
     330         192 :     if (len == TM2_ESCAPE) { /* some unknown length - could be escaped too */
     331           0 :         bytestream2_skip(&gb, 8); /* unused by decoder */
     332             :     } else {
     333         192 :         bytestream2_skip(&gb, 4); /* unused by decoder */
     334             :     }
     335             : 
     336         192 :     pos = bytestream2_tell(&gb);
     337         192 :     if (skip <= pos)
     338           0 :         return AVERROR_INVALIDDATA;
     339         192 :     init_get_bits(&ctx->gb, buf + pos, (skip - pos) * 8);
     340         192 :     if ((ret = tm2_build_huff_table(ctx, &codes)) < 0)
     341           0 :         return ret;
     342         192 :     bytestream2_skip(&gb, ((get_bits_count(&ctx->gb) + 31) >> 5) << 2);
     343             : 
     344         192 :     toks >>= 1;
     345             :     /* check if we have sane number of tokens */
     346         192 :     if ((toks < 0) || (toks > 0xFFFFFF)) {
     347           0 :         av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect number of tokens: %i\n", toks);
     348           0 :         ret = AVERROR_INVALIDDATA;
     349           0 :         goto end;
     350             :     }
     351         192 :     ret = av_reallocp_array(&ctx->tokens[stream_id], toks, sizeof(int));
     352         192 :     if (ret < 0) {
     353           0 :         ctx->tok_lens[stream_id] = 0;
     354           0 :         goto end;
     355             :     }
     356         192 :     ctx->tok_lens[stream_id] = toks;
     357         192 :     len = bytestream2_get_be32(&gb);
     358         192 :     if (len > 0) {
     359         189 :         pos = bytestream2_tell(&gb);
     360         189 :         if (skip <= pos) {
     361           0 :             ret = AVERROR_INVALIDDATA;
     362           0 :             goto end;
     363             :         }
     364         189 :         init_get_bits(&ctx->gb, buf + pos, (skip - pos) * 8);
     365     2353429 :         for (i = 0; i < toks; i++) {
     366     2353240 :             if (get_bits_left(&ctx->gb) <= 0) {
     367           0 :                 av_log(ctx->avctx, AV_LOG_ERROR, "Incorrect number of tokens: %i\n", toks);
     368           0 :                 ret = AVERROR_INVALIDDATA;
     369           0 :                 goto end;
     370             :             }
     371     2353240 :             ctx->tokens[stream_id][i] = tm2_get_token(&ctx->gb, &codes);
     372     2353240 :             if (stream_id <= TM2_MOT && ctx->tokens[stream_id][i] >= TM2_DELTAS || ctx->tokens[stream_id][i]<0) {
     373           0 :                 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid delta token index %d for type %d, n=%d\n",
     374           0 :                        ctx->tokens[stream_id][i], stream_id, i);
     375           0 :                 ret = AVERROR_INVALIDDATA;
     376           0 :                 goto end;
     377             :             }
     378             :         }
     379             :     } else {
     380          21 :         for (i = 0; i < toks; i++) {
     381          18 :             ctx->tokens[stream_id][i] = codes.recode[0];
     382          18 :             if (stream_id <= TM2_MOT && ctx->tokens[stream_id][i] >= TM2_DELTAS) {
     383           0 :                 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid delta token index %d for type %d, n=%d\n",
     384           0 :                        ctx->tokens[stream_id][i], stream_id, i);
     385           0 :                 ret = AVERROR_INVALIDDATA;
     386           0 :                 goto end;
     387             :             }
     388             :         }
     389             :     }
     390             : 
     391         192 :     ret = skip;
     392             : 
     393         192 : end:
     394         192 :     tm2_free_codes(&codes);
     395         192 :     return ret;
     396             : }
     397             : 
     398     2353258 : static inline int GET_TOK(TM2Context *ctx,int type)
     399             : {
     400     2353258 :     if (ctx->tok_ptrs[type] >= ctx->tok_lens[type]) {
     401           0 :         av_log(ctx->avctx, AV_LOG_ERROR, "Read token from stream %i out of bounds (%i>=%i)\n", type, ctx->tok_ptrs[type], ctx->tok_lens[type]);
     402           0 :         ctx->error = 1;
     403           0 :         return 0;
     404             :     }
     405     2353258 :     if (type <= TM2_MOT) {
     406     2209258 :         if (ctx->tokens[type][ctx->tok_ptrs[type]] >= TM2_DELTAS) {
     407           0 :             av_log(ctx->avctx, AV_LOG_ERROR, "token %d is too large\n", ctx->tokens[type][ctx->tok_ptrs[type]]);
     408           0 :             return 0;
     409             :         }
     410     2209258 :         return ctx->deltas[type][ctx->tokens[type][ctx->tok_ptrs[type]++]];
     411             :     }
     412      144000 :     return ctx->tokens[type][ctx->tok_ptrs[type]++];
     413             : }
     414             : 
     415             : /* blocks decoding routines */
     416             : 
     417             : /* common Y, U, V pointers initialisation */
     418             : #define TM2_INIT_POINTERS() \
     419             :     int *last, *clast; \
     420             :     int *Y, *U, *V;\
     421             :     int Ystride, Ustride, Vstride;\
     422             : \
     423             :     Ystride = ctx->y_stride;\
     424             :     Vstride = ctx->uv_stride;\
     425             :     Ustride = ctx->uv_stride;\
     426             :     Y = (ctx->cur?ctx->Y2:ctx->Y1) + by * 4 * Ystride + bx * 4;\
     427             :     V = (ctx->cur?ctx->V2:ctx->V1) + by * 2 * Vstride + bx * 2;\
     428             :     U = (ctx->cur?ctx->U2:ctx->U1) + by * 2 * Ustride + bx * 2;\
     429             :     last = ctx->last + bx * 4;\
     430             :     clast = ctx->clast + bx * 4;
     431             : 
     432             : #define TM2_INIT_POINTERS_2() \
     433             :     int *Yo, *Uo, *Vo;\
     434             :     int oYstride, oUstride, oVstride;\
     435             : \
     436             :     TM2_INIT_POINTERS();\
     437             :     oYstride = Ystride;\
     438             :     oVstride = Vstride;\
     439             :     oUstride = Ustride;\
     440             :     Yo = (ctx->cur?ctx->Y1:ctx->Y2) + by * 4 * oYstride + bx * 4;\
     441             :     Vo = (ctx->cur?ctx->V1:ctx->V2) + by * 2 * oVstride + bx * 2;\
     442             :     Uo = (ctx->cur?ctx->U1:ctx->U2) + by * 2 * oUstride + bx * 2;
     443             : 
     444             : /* recalculate last and delta values for next blocks */
     445             : #define TM2_RECALC_BLOCK(CHR, stride, last, CD) {\
     446             :     CD[0] = (unsigned)CHR[         1] - (unsigned)last[1];\
     447             :     CD[1] = (unsigned)CHR[stride + 1] - (unsigned) CHR[1];\
     448             :     last[0] = (int)CHR[stride + 0];\
     449             :     last[1] = (int)CHR[stride + 1];}
     450             : 
     451             : /* common operations - add deltas to 4x4 block of luma or 2x2 blocks of chroma */
     452      116660 : static inline void tm2_apply_deltas(TM2Context *ctx, int* Y, int stride, int *deltas, int *last)
     453             : {
     454             :     int ct, d;
     455             :     int i, j;
     456             : 
     457      583300 :     for (j = 0; j < 4; j++){
     458      466640 :         ct = ctx->D[j];
     459     2333200 :         for (i = 0; i < 4; i++){
     460     1866560 :             d        = deltas[i + j * 4];
     461     1866560 :             ct      += d;
     462     1866560 :             last[i] += ct;
     463     1866560 :             Y[i]     = av_clip_uint8(last[i]);
     464             :         }
     465      466640 :         Y        += stride;
     466      466640 :         ctx->D[j] = ct;
     467             :     }
     468      116660 : }
     469             : 
     470      233320 : static inline void tm2_high_chroma(int *data, int stride, int *last, unsigned *CD, int *deltas)
     471             : {
     472             :     int i, j;
     473      699960 :     for (j = 0; j < 2; j++) {
     474     1399920 :         for (i = 0; i < 2; i++)  {
     475      933280 :             CD[j]   += deltas[i + j * 2];
     476      933280 :             last[i] += CD[j];
     477      933280 :             data[i]  = last[i];
     478             :         }
     479      466640 :         data += stride;
     480             :     }
     481      233320 : }
     482             : 
     483       99888 : static inline void tm2_low_chroma(int *data, int stride, int *clast, int *CD, int *deltas, int bx)
     484             : {
     485             :     int t;
     486             :     int l;
     487             :     int prev;
     488             : 
     489       99888 :     if (bx > 0)
     490       99060 :         prev = clast[-3];
     491             :     else
     492         828 :         prev = 0;
     493       99888 :     t        = (CD[0] + CD[1]) >> 1;
     494       99888 :     l        = (prev - CD[0] - CD[1] + clast[1]) >> 1;
     495       99888 :     CD[1]    = CD[0] + CD[1] - t;
     496       99888 :     CD[0]    = t;
     497       99888 :     clast[0] = l;
     498             : 
     499       99888 :     tm2_high_chroma(data, stride, clast, CD, deltas);
     500       99888 : }
     501             : 
     502       66716 : static inline void tm2_hi_res_block(TM2Context *ctx, AVFrame *pic, int bx, int by)
     503             : {
     504             :     int i;
     505             :     int deltas[16];
     506       66716 :     TM2_INIT_POINTERS();
     507             : 
     508             :     /* hi-res chroma */
     509      333580 :     for (i = 0; i < 4; i++) {
     510      266864 :         deltas[i]     = GET_TOK(ctx, TM2_C_HI);
     511      266864 :         deltas[i + 4] = GET_TOK(ctx, TM2_C_HI);
     512             :     }
     513       66716 :     tm2_high_chroma(U, Ustride, clast,     ctx->CD,     deltas);
     514       66716 :     tm2_high_chroma(V, Vstride, clast + 2, ctx->CD + 2, deltas + 4);
     515             : 
     516             :     /* hi-res luma */
     517     1134172 :     for (i = 0; i < 16; i++)
     518     1067456 :         deltas[i] = GET_TOK(ctx, TM2_L_HI);
     519             : 
     520       66716 :     tm2_apply_deltas(ctx, Y, Ystride, deltas, last);
     521       66716 : }
     522             : 
     523       22463 : static inline void tm2_med_res_block(TM2Context *ctx, AVFrame *pic, int bx, int by)
     524             : {
     525             :     int i;
     526             :     int deltas[16];
     527       22463 :     TM2_INIT_POINTERS();
     528             : 
     529             :     /* low-res chroma */
     530       22463 :     deltas[0] = GET_TOK(ctx, TM2_C_LO);
     531       22463 :     deltas[1] = deltas[2] = deltas[3] = 0;
     532       22463 :     tm2_low_chroma(U, Ustride, clast, ctx->CD, deltas, bx);
     533             : 
     534       22463 :     deltas[0] = GET_TOK(ctx, TM2_C_LO);
     535       22463 :     deltas[1] = deltas[2] = deltas[3] = 0;
     536       22463 :     tm2_low_chroma(V, Vstride, clast + 2, ctx->CD + 2, deltas, bx);
     537             : 
     538             :     /* hi-res luma */
     539      381871 :     for (i = 0; i < 16; i++)
     540      359408 :         deltas[i] = GET_TOK(ctx, TM2_L_HI);
     541             : 
     542       22463 :     tm2_apply_deltas(ctx, Y, Ystride, deltas, last);
     543       22463 : }
     544             : 
     545       12092 : static inline void tm2_low_res_block(TM2Context *ctx, AVFrame *pic, int bx, int by)
     546             : {
     547             :     int i;
     548             :     int t1, t2;
     549             :     int deltas[16];
     550       12092 :     TM2_INIT_POINTERS();
     551             : 
     552             :     /* low-res chroma */
     553       12092 :     deltas[0] = GET_TOK(ctx, TM2_C_LO);
     554       12092 :     deltas[1] = deltas[2] = deltas[3] = 0;
     555       12092 :     tm2_low_chroma(U, Ustride, clast, ctx->CD, deltas, bx);
     556             : 
     557       12092 :     deltas[0] = GET_TOK(ctx, TM2_C_LO);
     558       12092 :     deltas[1] = deltas[2] = deltas[3] = 0;
     559       12092 :     tm2_low_chroma(V, Vstride, clast + 2, ctx->CD + 2, deltas, bx);
     560             : 
     561             :     /* low-res luma */
     562      205564 :     for (i = 0; i < 16; i++)
     563      193472 :         deltas[i] = 0;
     564             : 
     565       12092 :     deltas[ 0] = GET_TOK(ctx, TM2_L_LO);
     566       12092 :     deltas[ 2] = GET_TOK(ctx, TM2_L_LO);
     567       12092 :     deltas[ 8] = GET_TOK(ctx, TM2_L_LO);
     568       12092 :     deltas[10] = GET_TOK(ctx, TM2_L_LO);
     569             : 
     570       12092 :     if (bx > 0)
     571       12025 :         last[0] = (last[-1] - ctx->D[0] - ctx->D[1] - ctx->D[2] - ctx->D[3] + last[1]) >> 1;
     572             :     else
     573          67 :         last[0] = (last[1]  - ctx->D[0] - ctx->D[1] - ctx->D[2] - ctx->D[3])>> 1;
     574       12092 :     last[2] = (last[1] + last[3]) >> 1;
     575             : 
     576       12092 :     t1 = ctx->D[0] + ctx->D[1];
     577       12092 :     ctx->D[0] = t1 >> 1;
     578       12092 :     ctx->D[1] = t1 - (t1 >> 1);
     579       12092 :     t2 = ctx->D[2] + ctx->D[3];
     580       12092 :     ctx->D[2] = t2 >> 1;
     581       12092 :     ctx->D[3] = t2 - (t2 >> 1);
     582             : 
     583       12092 :     tm2_apply_deltas(ctx, Y, Ystride, deltas, last);
     584       12092 : }
     585             : 
     586       15389 : static inline void tm2_null_res_block(TM2Context *ctx, AVFrame *pic, int bx, int by)
     587             : {
     588             :     int i;
     589             :     int ct;
     590             :     int left, right, diff;
     591             :     int deltas[16];
     592       15389 :     TM2_INIT_POINTERS();
     593             : 
     594             :     /* null chroma */
     595       15389 :     deltas[0] = deltas[1] = deltas[2] = deltas[3] = 0;
     596       15389 :     tm2_low_chroma(U, Ustride, clast, ctx->CD, deltas, bx);
     597             : 
     598       15389 :     deltas[0] = deltas[1] = deltas[2] = deltas[3] = 0;
     599       15389 :     tm2_low_chroma(V, Vstride, clast + 2, ctx->CD + 2, deltas, bx);
     600             : 
     601             :     /* null luma */
     602      261613 :     for (i = 0; i < 16; i++)
     603      246224 :         deltas[i] = 0;
     604             : 
     605       15389 :     ct = ctx->D[0] + ctx->D[1] + ctx->D[2] + ctx->D[3];
     606             : 
     607       15389 :     if (bx > 0)
     608       15315 :         left = last[-1] - ct;
     609             :     else
     610          74 :         left = 0;
     611             : 
     612       15389 :     right   = last[3];
     613       15389 :     diff    = right - left;
     614       15389 :     last[0] = left + (diff >> 2);
     615       15389 :     last[1] = left + (diff >> 1);
     616       15389 :     last[2] = right - (diff >> 2);
     617       15389 :     last[3] = right;
     618             :     {
     619       15389 :         int tp = left;
     620             : 
     621       15389 :         ctx->D[0] = (tp + (ct >> 2)) - left;
     622       15389 :         left     += ctx->D[0];
     623       15389 :         ctx->D[1] = (tp + (ct >> 1)) - left;
     624       15389 :         left     += ctx->D[1];
     625       15389 :         ctx->D[2] = ((tp + ct) - (ct >> 2)) - left;
     626       15389 :         left     += ctx->D[2];
     627       15389 :         ctx->D[3] = (tp + ct) - left;
     628             :     }
     629       15389 :     tm2_apply_deltas(ctx, Y, Ystride, deltas, last);
     630       15389 : }
     631             : 
     632       20959 : static inline void tm2_still_block(TM2Context *ctx, AVFrame *pic, int bx, int by)
     633             : {
     634             :     int i, j;
     635       20959 :     TM2_INIT_POINTERS_2();
     636             : 
     637             :     /* update chroma */
     638       62877 :     for (j = 0; j < 2; j++) {
     639      125754 :         for (i = 0; i < 2; i++){
     640       83836 :             U[i] = Uo[i];
     641       83836 :             V[i] = Vo[i];
     642             :         }
     643       41918 :         U  += Ustride; V += Vstride;
     644       41918 :         Uo += oUstride; Vo += oVstride;
     645             :     }
     646       20959 :     U -= Ustride * 2;
     647       20959 :     V -= Vstride * 2;
     648       20959 :     TM2_RECALC_BLOCK(U, Ustride, clast, ctx->CD);
     649       20959 :     TM2_RECALC_BLOCK(V, Vstride, (clast + 2), (ctx->CD + 2));
     650             : 
     651             :     /* update deltas */
     652       20959 :     ctx->D[0] = Yo[3] - last[3];
     653       20959 :     ctx->D[1] = Yo[3 + oYstride] - Yo[3];
     654       20959 :     ctx->D[2] = Yo[3 + oYstride * 2] - Yo[3 + oYstride];
     655       20959 :     ctx->D[3] = Yo[3 + oYstride * 3] - Yo[3 + oYstride * 2];
     656             : 
     657      104795 :     for (j = 0; j < 4; j++) {
     658      419180 :         for (i = 0; i < 4; i++) {
     659      335344 :             Y[i]    = Yo[i];
     660      335344 :             last[i] = Yo[i];
     661             :         }
     662       83836 :         Y  += Ystride;
     663       83836 :         Yo += oYstride;
     664             :     }
     665       20959 : }
     666             : 
     667        5383 : static inline void tm2_update_block(TM2Context *ctx, AVFrame *pic, int bx, int by)
     668             : {
     669             :     int i, j;
     670             :     int d;
     671        5383 :     TM2_INIT_POINTERS_2();
     672             : 
     673             :     /* update chroma */
     674       16149 :     for (j = 0; j < 2; j++) {
     675       32298 :         for (i = 0; i < 2; i++) {
     676       21532 :             U[i] = Uo[i] + GET_TOK(ctx, TM2_UPD);
     677       21532 :             V[i] = Vo[i] + GET_TOK(ctx, TM2_UPD);
     678             :         }
     679       10766 :         U  += Ustride;
     680       10766 :         V  += Vstride;
     681       10766 :         Uo += oUstride;
     682       10766 :         Vo += oVstride;
     683             :     }
     684        5383 :     U -= Ustride * 2;
     685        5383 :     V -= Vstride * 2;
     686        5383 :     TM2_RECALC_BLOCK(U, Ustride, clast, ctx->CD);
     687        5383 :     TM2_RECALC_BLOCK(V, Vstride, (clast + 2), (ctx->CD + 2));
     688             : 
     689             :     /* update deltas */
     690        5383 :     ctx->D[0] = Yo[3] - last[3];
     691        5383 :     ctx->D[1] = Yo[3 + oYstride] - Yo[3];
     692        5383 :     ctx->D[2] = Yo[3 + oYstride * 2] - Yo[3 + oYstride];
     693        5383 :     ctx->D[3] = Yo[3 + oYstride * 3] - Yo[3 + oYstride * 2];
     694             : 
     695       26915 :     for (j = 0; j < 4; j++) {
     696       21532 :         d = last[3];
     697      107660 :         for (i = 0; i < 4; i++) {
     698       86128 :             Y[i]    = Yo[i] + GET_TOK(ctx, TM2_UPD);
     699       86128 :             last[i] = Y[i];
     700             :         }
     701       21532 :         ctx->D[j] = last[3] - d;
     702       21532 :         Y  += Ystride;
     703       21532 :         Yo += oYstride;
     704             :     }
     705        5383 : }
     706             : 
     707         998 : static inline void tm2_motion_block(TM2Context *ctx, AVFrame *pic, int bx, int by)
     708             : {
     709             :     int i, j;
     710             :     int mx, my;
     711         998 :     TM2_INIT_POINTERS_2();
     712             : 
     713         998 :     mx = GET_TOK(ctx, TM2_MOT);
     714         998 :     my = GET_TOK(ctx, TM2_MOT);
     715         998 :     mx = av_clip(mx, -(bx * 4 + 4), ctx->avctx->width  - bx * 4);
     716         998 :     my = av_clip(my, -(by * 4 + 4), ctx->avctx->height - by * 4);
     717             : 
     718         998 :     if (4*bx+mx<0 || 4*by+my<0 || 4*bx+mx+4 > ctx->avctx->width || 4*by+my+4 > ctx->avctx->height) {
     719           0 :         av_log(ctx->avctx, AV_LOG_ERROR, "MV out of picture\n");
     720           0 :         return;
     721             :     }
     722             : 
     723         998 :     Yo += my * oYstride + mx;
     724         998 :     Uo += (my >> 1) * oUstride + (mx >> 1);
     725         998 :     Vo += (my >> 1) * oVstride + (mx >> 1);
     726             : 
     727             :     /* copy chroma */
     728        2994 :     for (j = 0; j < 2; j++) {
     729        5988 :         for (i = 0; i < 2; i++) {
     730        3992 :             U[i] = Uo[i];
     731        3992 :             V[i] = Vo[i];
     732             :         }
     733        1996 :         U  += Ustride;
     734        1996 :         V  += Vstride;
     735        1996 :         Uo += oUstride;
     736        1996 :         Vo += oVstride;
     737             :     }
     738         998 :     U -= Ustride * 2;
     739         998 :     V -= Vstride * 2;
     740         998 :     TM2_RECALC_BLOCK(U, Ustride, clast, ctx->CD);
     741         998 :     TM2_RECALC_BLOCK(V, Vstride, (clast + 2), (ctx->CD + 2));
     742             : 
     743             :     /* copy luma */
     744        4990 :     for (j = 0; j < 4; j++) {
     745       19960 :         for (i = 0; i < 4; i++) {
     746       15968 :             Y[i] = Yo[i];
     747             :         }
     748        3992 :         Y  += Ystride;
     749        3992 :         Yo += oYstride;
     750             :     }
     751             :     /* calculate deltas */
     752         998 :     Y -= Ystride * 4;
     753         998 :     ctx->D[0] = Y[3] - last[3];
     754         998 :     ctx->D[1] = Y[3 + Ystride] - Y[3];
     755         998 :     ctx->D[2] = Y[3 + Ystride * 2] - Y[3 + Ystride];
     756         998 :     ctx->D[3] = Y[3 + Ystride * 3] - Y[3 + Ystride * 2];
     757        4990 :     for (i = 0; i < 4; i++)
     758        3992 :         last[i] = Y[i + Ystride * 3];
     759             : }
     760             : 
     761          30 : static int tm2_decode_blocks(TM2Context *ctx, AVFrame *p)
     762             : {
     763             :     int i, j;
     764          30 :     int w = ctx->avctx->width, h = ctx->avctx->height, bw = w >> 2, bh = h >> 2, cw = w >> 1;
     765             :     int type;
     766          30 :     int keyframe = 1;
     767             :     int *Y, *U, *V;
     768             :     uint8_t *dst;
     769             : 
     770         240 :     for (i = 0; i < TM2_NUM_STREAMS; i++)
     771         210 :         ctx->tok_ptrs[i] = 0;
     772             : 
     773          30 :     if (ctx->tok_lens[TM2_TYPE]<bw*bh) {
     774           0 :         av_log(ctx->avctx,AV_LOG_ERROR,"Got %i tokens for %i blocks\n",ctx->tok_lens[TM2_TYPE],bw*bh);
     775           0 :         return AVERROR_INVALIDDATA;
     776             :     }
     777             : 
     778          30 :     memset(ctx->last, 0, 4 * bw * sizeof(int));
     779          30 :     memset(ctx->clast, 0, 4 * bw * sizeof(int));
     780             : 
     781        1830 :     for (j = 0; j < bh; j++) {
     782        1800 :         memset(ctx->D, 0, 4 * sizeof(int));
     783        1800 :         memset(ctx->CD, 0, 4 * sizeof(int));
     784      145800 :         for (i = 0; i < bw; i++) {
     785      144000 :             type = GET_TOK(ctx, TM2_TYPE);
     786      144000 :             switch(type) {
     787       66716 :             case TM2_HI_RES:
     788       66716 :                 tm2_hi_res_block(ctx, p, i, j);
     789       66716 :                 break;
     790       22463 :             case TM2_MED_RES:
     791       22463 :                 tm2_med_res_block(ctx, p, i, j);
     792       22463 :                 break;
     793       12092 :             case TM2_LOW_RES:
     794       12092 :                 tm2_low_res_block(ctx, p, i, j);
     795       12092 :                 break;
     796       15389 :             case TM2_NULL_RES:
     797       15389 :                 tm2_null_res_block(ctx, p, i, j);
     798       15389 :                 break;
     799        5383 :             case TM2_UPDATE:
     800        5383 :                 tm2_update_block(ctx, p, i, j);
     801        5383 :                 keyframe = 0;
     802        5383 :                 break;
     803       20959 :             case TM2_STILL:
     804       20959 :                 tm2_still_block(ctx, p, i, j);
     805       20959 :                 keyframe = 0;
     806       20959 :                 break;
     807         998 :             case TM2_MOTION:
     808         998 :                 tm2_motion_block(ctx, p, i, j);
     809         998 :                 keyframe = 0;
     810         998 :                 break;
     811           0 :             default:
     812           0 :                 av_log(ctx->avctx, AV_LOG_ERROR, "Skipping unknown block type %i\n", type);
     813             :             }
     814      144000 :             if (ctx->error)
     815           0 :                 return AVERROR_INVALIDDATA;
     816             :         }
     817             :     }
     818             : 
     819             :     /* copy data from our buffer to AVFrame */
     820          30 :     Y = (ctx->cur?ctx->Y2:ctx->Y1);
     821          30 :     U = (ctx->cur?ctx->U2:ctx->U1);
     822          30 :     V = (ctx->cur?ctx->V2:ctx->V1);
     823          30 :     dst = p->data[0];
     824        7230 :     for (j = 0; j < h; j++) {
     825     2311200 :         for (i = 0; i < w; i++) {
     826     2304000 :             int y = Y[i], u = U[i >> 1], v = V[i >> 1];
     827     2304000 :             dst[3*i+0] = av_clip_uint8(y + v);
     828     2304000 :             dst[3*i+1] = av_clip_uint8(y);
     829     2304000 :             dst[3*i+2] = av_clip_uint8(y + u);
     830             :         }
     831             : 
     832             :         /* horizontal edge extension */
     833        7200 :         Y[-4]    = Y[-3]    = Y[-2]    = Y[-1] = Y[0];
     834        7200 :         Y[w + 3] = Y[w + 2] = Y[w + 1] = Y[w]  = Y[w - 1];
     835             : 
     836             :         /* vertical edge extension */
     837        7200 :         if (j == 0) {
     838          30 :             memcpy(Y - 4 - 1 * ctx->y_stride, Y - 4, ctx->y_stride);
     839          30 :             memcpy(Y - 4 - 2 * ctx->y_stride, Y - 4, ctx->y_stride);
     840          30 :             memcpy(Y - 4 - 3 * ctx->y_stride, Y - 4, ctx->y_stride);
     841          30 :             memcpy(Y - 4 - 4 * ctx->y_stride, Y - 4, ctx->y_stride);
     842        7170 :         } else if (j == h - 1) {
     843          30 :             memcpy(Y - 4 + 1 * ctx->y_stride, Y - 4, ctx->y_stride);
     844          30 :             memcpy(Y - 4 + 2 * ctx->y_stride, Y - 4, ctx->y_stride);
     845          30 :             memcpy(Y - 4 + 3 * ctx->y_stride, Y - 4, ctx->y_stride);
     846          30 :             memcpy(Y - 4 + 4 * ctx->y_stride, Y - 4, ctx->y_stride);
     847             :         }
     848             : 
     849        7200 :         Y += ctx->y_stride;
     850        7200 :         if (j & 1) {
     851             :             /* horizontal edge extension */
     852        3600 :             U[-2]     = U[-1] = U[0];
     853        3600 :             V[-2]     = V[-1] = V[0];
     854        3600 :             U[cw + 1] = U[cw] = U[cw - 1];
     855        3600 :             V[cw + 1] = V[cw] = V[cw - 1];
     856             : 
     857             :             /* vertical edge extension */
     858        3600 :             if (j == 1) {
     859          30 :                 memcpy(U - 2 - 1 * ctx->uv_stride, U - 2, ctx->uv_stride);
     860          30 :                 memcpy(V - 2 - 1 * ctx->uv_stride, V - 2, ctx->uv_stride);
     861          30 :                 memcpy(U - 2 - 2 * ctx->uv_stride, U - 2, ctx->uv_stride);
     862          30 :                 memcpy(V - 2 - 2 * ctx->uv_stride, V - 2, ctx->uv_stride);
     863        3570 :             } else if (j == h - 1) {
     864          30 :                 memcpy(U - 2 + 1 * ctx->uv_stride, U - 2, ctx->uv_stride);
     865          30 :                 memcpy(V - 2 + 1 * ctx->uv_stride, V - 2, ctx->uv_stride);
     866          30 :                 memcpy(U - 2 + 2 * ctx->uv_stride, U - 2, ctx->uv_stride);
     867          30 :                 memcpy(V - 2 + 2 * ctx->uv_stride, V - 2, ctx->uv_stride);
     868             :             }
     869             : 
     870        3600 :             U += ctx->uv_stride;
     871        3600 :             V += ctx->uv_stride;
     872             :         }
     873        7200 :         dst += p->linesize[0];
     874             :     }
     875             : 
     876          30 :     return keyframe;
     877             : }
     878             : 
     879             : static const int tm2_stream_order[TM2_NUM_STREAMS] = {
     880             :     TM2_C_HI, TM2_C_LO, TM2_L_HI, TM2_L_LO, TM2_UPD, TM2_MOT, TM2_TYPE
     881             : };
     882             : 
     883             : #define TM2_HEADER_SIZE 40
     884             : 
     885          30 : static int decode_frame(AVCodecContext *avctx,
     886             :                         void *data, int *got_frame,
     887             :                         AVPacket *avpkt)
     888             : {
     889          30 :     TM2Context * const l = avctx->priv_data;
     890          30 :     const uint8_t *buf   = avpkt->data;
     891          30 :     int buf_size         = avpkt->size & ~3;
     892          30 :     AVFrame * const p    = l->pic;
     893          30 :     int offset           = TM2_HEADER_SIZE;
     894             :     int i, t, ret;
     895             : 
     896          30 :     l->error = 0;
     897             : 
     898          30 :     av_fast_padded_malloc(&l->buffer, &l->buffer_size, buf_size);
     899          30 :     if (!l->buffer) {
     900           0 :         av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer\n");
     901           0 :         return AVERROR(ENOMEM);
     902             :     }
     903             : 
     904          30 :     if ((ret = ff_reget_buffer(avctx, p)) < 0)
     905           0 :         return ret;
     906             : 
     907          30 :     l->bdsp.bswap_buf((uint32_t *) l->buffer, (const uint32_t *) buf,
     908             :                       buf_size >> 2);
     909             : 
     910          30 :     if ((ret = tm2_read_header(l, l->buffer)) < 0) {
     911           0 :         return ret;
     912             :     }
     913             : 
     914         240 :     for (i = 0; i < TM2_NUM_STREAMS; i++) {
     915         210 :         if (offset >= buf_size) {
     916           0 :             av_log(avctx, AV_LOG_ERROR, "no space for tm2_read_stream\n");
     917           0 :             return AVERROR_INVALIDDATA;
     918             :         }
     919             : 
     920         210 :         t = tm2_read_stream(l, l->buffer + offset, tm2_stream_order[i],
     921             :                             buf_size - offset);
     922         210 :         if (t < 0) {
     923           0 :             int j = tm2_stream_order[i];
     924           0 :             if (l->tok_lens[j])
     925           0 :                 memset(l->tokens[j], 0, sizeof(**l->tokens) * l->tok_lens[j]);
     926           0 :             return t;
     927             :         }
     928         210 :         offset += t;
     929             :     }
     930          30 :     p->key_frame = tm2_decode_blocks(l, p);
     931          30 :     if (p->key_frame)
     932           5 :         p->pict_type = AV_PICTURE_TYPE_I;
     933             :     else
     934          25 :         p->pict_type = AV_PICTURE_TYPE_P;
     935             : 
     936          30 :     l->cur = !l->cur;
     937          30 :     *got_frame      = 1;
     938          30 :     ret = av_frame_ref(data, l->pic);
     939             : 
     940          30 :     return (ret < 0) ? ret : buf_size;
     941             : }
     942             : 
     943           2 : static av_cold int decode_init(AVCodecContext *avctx)
     944             : {
     945           2 :     TM2Context * const l = avctx->priv_data;
     946           2 :     int i, w = avctx->width, h = avctx->height;
     947             : 
     948           2 :     if ((avctx->width & 3) || (avctx->height & 3)) {
     949           0 :         av_log(avctx, AV_LOG_ERROR, "Width and height must be multiple of 4\n");
     950           0 :         return AVERROR(EINVAL);
     951             :     }
     952             : 
     953           2 :     l->avctx       = avctx;
     954           2 :     avctx->pix_fmt = AV_PIX_FMT_BGR24;
     955             : 
     956           2 :     l->pic = av_frame_alloc();
     957           2 :     if (!l->pic)
     958           0 :         return AVERROR(ENOMEM);
     959             : 
     960           2 :     ff_bswapdsp_init(&l->bdsp);
     961             : 
     962           2 :     l->last  = av_malloc_array(w >> 2, 4 * sizeof(*l->last) );
     963           2 :     l->clast = av_malloc_array(w >> 2, 4 * sizeof(*l->clast));
     964             : 
     965          16 :     for (i = 0; i < TM2_NUM_STREAMS; i++) {
     966          14 :         l->tokens[i] = NULL;
     967          14 :         l->tok_lens[i] = 0;
     968             :     }
     969             : 
     970           2 :     w += 8;
     971           2 :     h += 8;
     972           2 :     l->Y1_base = av_calloc(w * h, sizeof(*l->Y1_base));
     973           2 :     l->Y2_base = av_calloc(w * h, sizeof(*l->Y2_base));
     974           2 :     l->y_stride = w;
     975           2 :     w = (w + 1) >> 1;
     976           2 :     h = (h + 1) >> 1;
     977           2 :     l->U1_base = av_calloc(w * h, sizeof(*l->U1_base));
     978           2 :     l->V1_base = av_calloc(w * h, sizeof(*l->V1_base));
     979           2 :     l->U2_base = av_calloc(w * h, sizeof(*l->U2_base));
     980           2 :     l->V2_base = av_calloc(w * h, sizeof(*l->V1_base));
     981           2 :     l->uv_stride = w;
     982           2 :     l->cur = 0;
     983           4 :     if (!l->Y1_base || !l->Y2_base || !l->U1_base ||
     984           6 :         !l->V1_base || !l->U2_base || !l->V2_base ||
     985           4 :         !l->last    || !l->clast) {
     986           0 :         av_freep(&l->Y1_base);
     987           0 :         av_freep(&l->Y2_base);
     988           0 :         av_freep(&l->U1_base);
     989           0 :         av_freep(&l->U2_base);
     990           0 :         av_freep(&l->V1_base);
     991           0 :         av_freep(&l->V2_base);
     992           0 :         av_freep(&l->last);
     993           0 :         av_freep(&l->clast);
     994           0 :         av_frame_free(&l->pic);
     995           0 :         return AVERROR(ENOMEM);
     996             :     }
     997           2 :     l->Y1 = l->Y1_base + l->y_stride  * 4 + 4;
     998           2 :     l->Y2 = l->Y2_base + l->y_stride  * 4 + 4;
     999           2 :     l->U1 = l->U1_base + l->uv_stride * 2 + 2;
    1000           2 :     l->U2 = l->U2_base + l->uv_stride * 2 + 2;
    1001           2 :     l->V1 = l->V1_base + l->uv_stride * 2 + 2;
    1002           2 :     l->V2 = l->V2_base + l->uv_stride * 2 + 2;
    1003             : 
    1004           2 :     return 0;
    1005             : }
    1006             : 
    1007           2 : static av_cold int decode_end(AVCodecContext *avctx)
    1008             : {
    1009           2 :     TM2Context * const l = avctx->priv_data;
    1010             :     int i;
    1011             : 
    1012           2 :     av_free(l->last);
    1013           2 :     av_free(l->clast);
    1014          16 :     for (i = 0; i < TM2_NUM_STREAMS; i++)
    1015          14 :         av_freep(&l->tokens[i]);
    1016           2 :     if (l->Y1) {
    1017           2 :         av_freep(&l->Y1_base);
    1018           2 :         av_freep(&l->U1_base);
    1019           2 :         av_freep(&l->V1_base);
    1020           2 :         av_freep(&l->Y2_base);
    1021           2 :         av_freep(&l->U2_base);
    1022           2 :         av_freep(&l->V2_base);
    1023             :     }
    1024           2 :     av_freep(&l->buffer);
    1025           2 :     l->buffer_size = 0;
    1026             : 
    1027           2 :     av_frame_free(&l->pic);
    1028             : 
    1029           2 :     return 0;
    1030             : }
    1031             : 
    1032             : AVCodec ff_truemotion2_decoder = {
    1033             :     .name           = "truemotion2",
    1034             :     .long_name      = NULL_IF_CONFIG_SMALL("Duck TrueMotion 2.0"),
    1035             :     .type           = AVMEDIA_TYPE_VIDEO,
    1036             :     .id             = AV_CODEC_ID_TRUEMOTION2,
    1037             :     .priv_data_size = sizeof(TM2Context),
    1038             :     .init           = decode_init,
    1039             :     .close          = decode_end,
    1040             :     .decode         = decode_frame,
    1041             :     .capabilities   = AV_CODEC_CAP_DR1,
    1042             : };

Generated by: LCOV version 1.13