Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (C) 2006  Aurelien Jacobs <aurel@gnuage.org>
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * FFmpeg is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with FFmpeg; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19.  */
  20.  
  21. /**
  22.  * @file
  23.  * VP5 compatible video decoder
  24.  */
  25.  
  26. #include <stdlib.h>
  27. #include <string.h>
  28.  
  29. #include "avcodec.h"
  30. #include "get_bits.h"
  31.  
  32. #include "vp56.h"
  33. #include "vp56data.h"
  34. #include "vp5data.h"
  35.  
  36.  
  37. static int vp5_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
  38. {
  39.     VP56RangeCoder *c = &s->c;
  40.     int rows, cols;
  41.  
  42.     ff_vp56_init_range_decoder(&s->c, buf, buf_size);
  43.     s->frames[VP56_FRAME_CURRENT]->key_frame = !vp56_rac_get(c);
  44.     vp56_rac_get(c);
  45.     ff_vp56_init_dequant(s, vp56_rac_gets(c, 6));
  46.     if (s->frames[VP56_FRAME_CURRENT]->key_frame)
  47.     {
  48.         vp56_rac_gets(c, 8);
  49.         if(vp56_rac_gets(c, 5) > 5)
  50.             return AVERROR_INVALIDDATA;
  51.         vp56_rac_gets(c, 2);
  52.         if (vp56_rac_get(c)) {
  53.             av_log(s->avctx, AV_LOG_ERROR, "interlacing not supported\n");
  54.             return AVERROR_PATCHWELCOME;
  55.         }
  56.         rows = vp56_rac_gets(c, 8);  /* number of stored macroblock rows */
  57.         cols = vp56_rac_gets(c, 8);  /* number of stored macroblock cols */
  58.         if (!rows || !cols) {
  59.             av_log(s->avctx, AV_LOG_ERROR, "Invalid size %dx%d\n",
  60.                    cols << 4, rows << 4);
  61.             return AVERROR_INVALIDDATA;
  62.         }
  63.         vp56_rac_gets(c, 8);  /* number of displayed macroblock rows */
  64.         vp56_rac_gets(c, 8);  /* number of displayed macroblock cols */
  65.         vp56_rac_gets(c, 2);
  66.         if (!s->macroblocks || /* first frame */
  67.             16*cols != s->avctx->coded_width ||
  68.             16*rows != s->avctx->coded_height) {
  69.             avcodec_set_dimensions(s->avctx, 16*cols, 16*rows);
  70.             return VP56_SIZE_CHANGE;
  71.         }
  72.     } else if (!s->macroblocks)
  73.         return AVERROR_INVALIDDATA;
  74.     return 0;
  75. }
  76.  
  77. static void vp5_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
  78. {
  79.     VP56RangeCoder *c = &s->c;
  80.     VP56Model *model = s->modelp;
  81.     int comp, di;
  82.  
  83.     for (comp=0; comp<2; comp++) {
  84.         int delta = 0;
  85.         if (vp56_rac_get_prob(c, model->vector_dct[comp])) {
  86.             int sign = vp56_rac_get_prob(c, model->vector_sig[comp]);
  87.             di  = vp56_rac_get_prob(c, model->vector_pdi[comp][0]);
  88.             di |= vp56_rac_get_prob(c, model->vector_pdi[comp][1]) << 1;
  89.             delta = vp56_rac_get_tree(c, ff_vp56_pva_tree,
  90.                                       model->vector_pdv[comp]);
  91.             delta = di | (delta << 2);
  92.             delta = (delta ^ -sign) + sign;
  93.         }
  94.         if (!comp)
  95.             vect->x = delta;
  96.         else
  97.             vect->y = delta;
  98.     }
  99. }
  100.  
  101. static void vp5_parse_vector_models(VP56Context *s)
  102. {
  103.     VP56RangeCoder *c = &s->c;
  104.     VP56Model *model = s->modelp;
  105.     int comp, node;
  106.  
  107.     for (comp=0; comp<2; comp++) {
  108.         if (vp56_rac_get_prob(c, vp5_vmc_pct[comp][0]))
  109.             model->vector_dct[comp] = vp56_rac_gets_nn(c, 7);
  110.         if (vp56_rac_get_prob(c, vp5_vmc_pct[comp][1]))
  111.             model->vector_sig[comp] = vp56_rac_gets_nn(c, 7);
  112.         if (vp56_rac_get_prob(c, vp5_vmc_pct[comp][2]))
  113.             model->vector_pdi[comp][0] = vp56_rac_gets_nn(c, 7);
  114.         if (vp56_rac_get_prob(c, vp5_vmc_pct[comp][3]))
  115.             model->vector_pdi[comp][1] = vp56_rac_gets_nn(c, 7);
  116.     }
  117.  
  118.     for (comp=0; comp<2; comp++)
  119.         for (node=0; node<7; node++)
  120.             if (vp56_rac_get_prob(c, vp5_vmc_pct[comp][4 + node]))
  121.                 model->vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
  122. }
  123.  
  124. static int vp5_parse_coeff_models(VP56Context *s)
  125. {
  126.     VP56RangeCoder *c = &s->c;
  127.     VP56Model *model = s->modelp;
  128.     uint8_t def_prob[11];
  129.     int node, cg, ctx;
  130.     int ct;    /* code type */
  131.     int pt;    /* plane type (0 for Y, 1 for U or V) */
  132.  
  133.     memset(def_prob, 0x80, sizeof(def_prob));
  134.  
  135.     for (pt=0; pt<2; pt++)
  136.         for (node=0; node<11; node++)
  137.             if (vp56_rac_get_prob(c, vp5_dccv_pct[pt][node])) {
  138.                 def_prob[node] = vp56_rac_gets_nn(c, 7);
  139.                 model->coeff_dccv[pt][node] = def_prob[node];
  140.             } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
  141.                 model->coeff_dccv[pt][node] = def_prob[node];
  142.             }
  143.  
  144.     for (ct=0; ct<3; ct++)
  145.         for (pt=0; pt<2; pt++)
  146.             for (cg=0; cg<6; cg++)
  147.                 for (node=0; node<11; node++)
  148.                     if (vp56_rac_get_prob(c, vp5_ract_pct[ct][pt][cg][node])) {
  149.                         def_prob[node] = vp56_rac_gets_nn(c, 7);
  150.                         model->coeff_ract[pt][ct][cg][node] = def_prob[node];
  151.                     } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
  152.                         model->coeff_ract[pt][ct][cg][node] = def_prob[node];
  153.                     }
  154.  
  155.     /* coeff_dcct is a linear combination of coeff_dccv */
  156.     for (pt=0; pt<2; pt++)
  157.         for (ctx=0; ctx<36; ctx++)
  158.             for (node=0; node<5; node++)
  159.                 model->coeff_dcct[pt][ctx][node] = av_clip(((model->coeff_dccv[pt][node] * vp5_dccv_lc[node][ctx][0] + 128) >> 8) + vp5_dccv_lc[node][ctx][1], 1, 254);
  160.  
  161.     /* coeff_acct is a linear combination of coeff_ract */
  162.     for (ct=0; ct<3; ct++)
  163.         for (pt=0; pt<2; pt++)
  164.             for (cg=0; cg<3; cg++)
  165.                 for (ctx=0; ctx<6; ctx++)
  166.                     for (node=0; node<5; node++)
  167.                         model->coeff_acct[pt][ct][cg][ctx][node] = av_clip(((model->coeff_ract[pt][ct][cg][node] * vp5_ract_lc[ct][cg][node][ctx][0] + 128) >> 8) + vp5_ract_lc[ct][cg][node][ctx][1], 1, 254);
  168.     return 0;
  169. }
  170.  
  171. static void vp5_parse_coeff(VP56Context *s)
  172. {
  173.     VP56RangeCoder *c = &s->c;
  174.     VP56Model *model = s->modelp;
  175.     uint8_t *permute = s->idct_scantable;
  176.     uint8_t *model1, *model2;
  177.     int coeff, sign, coeff_idx;
  178.     int b, i, cg, idx, ctx, ctx_last;
  179.     int pt = 0;    /* plane type (0 for Y, 1 for U or V) */
  180.  
  181.     for (b=0; b<6; b++) {
  182.         int ct = 1;    /* code type */
  183.  
  184.         if (b > 3) pt = 1;
  185.  
  186.         ctx = 6*s->coeff_ctx[ff_vp56_b6to4[b]][0]
  187.               + s->above_blocks[s->above_block_idx[b]].not_null_dc;
  188.         model1 = model->coeff_dccv[pt];
  189.         model2 = model->coeff_dcct[pt][ctx];
  190.  
  191.         coeff_idx = 0;
  192.         for (;;) {
  193.             if (vp56_rac_get_prob(c, model2[0])) {
  194.                 if (vp56_rac_get_prob(c, model2[2])) {
  195.                     if (vp56_rac_get_prob(c, model2[3])) {
  196.                         s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 4;
  197.                         idx = vp56_rac_get_tree(c, ff_vp56_pc_tree, model1);
  198.                         sign = vp56_rac_get(c);
  199.                         coeff = ff_vp56_coeff_bias[idx+5];
  200.                         for (i=ff_vp56_coeff_bit_length[idx]; i>=0; i--)
  201.                             coeff += vp56_rac_get_prob(c, ff_vp56_coeff_parse_table[idx][i]) << i;
  202.                     } else {
  203.                         if (vp56_rac_get_prob(c, model2[4])) {
  204.                             coeff = 3 + vp56_rac_get_prob(c, model1[5]);
  205.                             s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 3;
  206.                         } else {
  207.                             coeff = 2;
  208.                             s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 2;
  209.                         }
  210.                         sign = vp56_rac_get(c);
  211.                     }
  212.                     ct = 2;
  213.                 } else {
  214.                     ct = 1;
  215.                     s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 1;
  216.                     sign = vp56_rac_get(c);
  217.                     coeff = 1;
  218.                 }
  219.                 coeff = (coeff ^ -sign) + sign;
  220.                 if (coeff_idx)
  221.                     coeff *= s->dequant_ac;
  222.                 s->block_coeff[b][permute[coeff_idx]] = coeff;
  223.             } else {
  224.                 if (ct && !vp56_rac_get_prob(c, model2[1]))
  225.                     break;
  226.                 ct = 0;
  227.                 s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 0;
  228.             }
  229.             coeff_idx++;
  230.             if (coeff_idx >= 64)
  231.                 break;
  232.  
  233.             cg = vp5_coeff_groups[coeff_idx];
  234.             ctx = s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx];
  235.             model1 = model->coeff_ract[pt][ct][cg];
  236.             model2 = cg > 2 ? model1 : model->coeff_acct[pt][ct][cg][ctx];
  237.         }
  238.  
  239.         ctx_last = FFMIN(s->coeff_ctx_last[ff_vp56_b6to4[b]], 24);
  240.         s->coeff_ctx_last[ff_vp56_b6to4[b]] = coeff_idx;
  241.         if (coeff_idx < ctx_last)
  242.             for (i=coeff_idx; i<=ctx_last; i++)
  243.                 s->coeff_ctx[ff_vp56_b6to4[b]][i] = 5;
  244.         s->above_blocks[s->above_block_idx[b]].not_null_dc = s->coeff_ctx[ff_vp56_b6to4[b]][0];
  245.     }
  246. }
  247.  
  248. static void vp5_default_models_init(VP56Context *s)
  249. {
  250.     VP56Model *model = s->modelp;
  251.     int i;
  252.  
  253.     for (i=0; i<2; i++) {
  254.         model->vector_sig[i] = 0x80;
  255.         model->vector_dct[i] = 0x80;
  256.         model->vector_pdi[i][0] = 0x55;
  257.         model->vector_pdi[i][1] = 0x80;
  258.     }
  259.     memcpy(model->mb_types_stats, ff_vp56_def_mb_types_stats, sizeof(model->mb_types_stats));
  260.     memset(model->vector_pdv, 0x80, sizeof(model->vector_pdv));
  261. }
  262.  
  263. static av_cold int vp5_decode_init(AVCodecContext *avctx)
  264. {
  265.     VP56Context *s = avctx->priv_data;
  266.     int ret;
  267.  
  268.     if ((ret = ff_vp56_init(avctx, 1, 0)) < 0)
  269.         return ret;
  270.     s->vp56_coord_div = vp5_coord_div;
  271.     s->parse_vector_adjustment = vp5_parse_vector_adjustment;
  272.     s->parse_coeff = vp5_parse_coeff;
  273.     s->default_models_init = vp5_default_models_init;
  274.     s->parse_vector_models = vp5_parse_vector_models;
  275.     s->parse_coeff_models = vp5_parse_coeff_models;
  276.     s->parse_header = vp5_parse_header;
  277.  
  278.     return 0;
  279. }
  280.  
  281. AVCodec ff_vp5_decoder = {
  282.     .name           = "vp5",
  283.     .long_name      = NULL_IF_CONFIG_SMALL("On2 VP5"),
  284.     .type           = AVMEDIA_TYPE_VIDEO,
  285.     .id             = AV_CODEC_ID_VP5,
  286.     .priv_data_size = sizeof(VP56Context),
  287.     .init           = vp5_decode_init,
  288.     .close          = ff_vp56_free,
  289.     .decode         = ff_vp56_decode_frame,
  290.     .capabilities   = CODEC_CAP_DR1,
  291. };
  292.