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