LCOV - code coverage report
Current view: top level - libavcodec - mdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 109 120 90.8 %
Date: 2017-12-18 06:23:41 Functions: 6 7 85.7 %

          Line data    Source code
       1             : /*
       2             :  * Sony PlayStation MDEC (Motion DECoder)
       3             :  * Copyright (c) 2003 Michael Niedermayer
       4             :  *
       5             :  * based upon code from Sebastian Jedruszkiewicz <elf@frogger.rules.pl>
       6             :  *
       7             :  * This file is part of FFmpeg.
       8             :  *
       9             :  * FFmpeg is free software; you can redistribute it and/or
      10             :  * modify it under the terms of the GNU Lesser General Public
      11             :  * License as published by the Free Software Foundation; either
      12             :  * version 2.1 of the License, or (at your option) any later version.
      13             :  *
      14             :  * FFmpeg is distributed in the hope that it will be useful,
      15             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      16             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      17             :  * Lesser General Public License for more details.
      18             :  *
      19             :  * You should have received a copy of the GNU Lesser General Public
      20             :  * License along with FFmpeg; if not, write to the Free Software
      21             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      22             :  */
      23             : 
      24             : /**
      25             :  * @file
      26             :  * Sony PlayStation MDEC (Motion DECoder)
      27             :  * This is very similar to intra-only MPEG-1.
      28             :  */
      29             : 
      30             : #include "avcodec.h"
      31             : #include "blockdsp.h"
      32             : #include "bswapdsp.h"
      33             : #include "idctdsp.h"
      34             : #include "mpeg12.h"
      35             : #include "thread.h"
      36             : 
      37             : typedef struct MDECContext {
      38             :     AVCodecContext *avctx;
      39             :     BlockDSPContext bdsp;
      40             :     BswapDSPContext bbdsp;
      41             :     IDCTDSPContext idsp;
      42             :     ThreadFrame frame;
      43             :     GetBitContext gb;
      44             :     ScanTable scantable;
      45             :     int version;
      46             :     int qscale;
      47             :     int last_dc[3];
      48             :     int mb_width;
      49             :     int mb_height;
      50             :     int mb_x, mb_y;
      51             :     DECLARE_ALIGNED(32, int16_t, block)[6][64];
      52             :     DECLARE_ALIGNED(16, uint16_t, quant_matrix)[64];
      53             :     uint8_t *bitstream_buffer;
      54             :     unsigned int bitstream_buffer_size;
      55             :     int block_last_index[6];
      56             : } MDECContext;
      57             : 
      58             : //very similar to MPEG-1
      59      285689 : static inline int mdec_decode_block_intra(MDECContext *a, int16_t *block, int n)
      60             : {
      61             :     int level, diff, i, j, run;
      62             :     int component;
      63      285689 :     RLTable *rl = &ff_rl_mpeg1;
      64      285689 :     uint8_t * const scantable = a->scantable.permutated;
      65      285689 :     const uint16_t *quant_matrix = a->quant_matrix;
      66      285689 :     const int qscale = a->qscale;
      67             : 
      68             :     /* DC coefficient */
      69      285689 :     if (a->version == 2) {
      70      214889 :         block[0] = 2 * get_sbits(&a->gb, 10) + 1024;
      71             :     } else {
      72       70800 :         component = (n <= 3 ? 0 : n - 4 + 1);
      73       70800 :         diff = decode_dc(&a->gb, component);
      74       70800 :         if (diff >= 0xffff)
      75           0 :             return AVERROR_INVALIDDATA;
      76       70800 :         a->last_dc[component] += diff;
      77       70800 :         block[0] = a->last_dc[component] * (1 << 3);
      78             :     }
      79             : 
      80      285689 :     i = 0;
      81             :     {
      82      285689 :         OPEN_READER(re, &a->gb);
      83             :         /* now quantify & encode AC coefficients */
      84             :         for (;;) {
      85     4638889 :             UPDATE_CACHE(re, &a->gb);
      86     2462289 :             GET_RL_VLC(level, run, re, &a->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
      87             : 
      88     2462289 :             if (level == 127) {
      89      285688 :                 break;
      90     2176601 :             } else if (level != 0) {
      91     2133703 :                 i += run;
      92     2133703 :                 if (i > 63) {
      93           1 :                     av_log(a->avctx, AV_LOG_ERROR,
      94             :                            "ac-tex damaged at %d %d\n", a->mb_x, a->mb_y);
      95           1 :                     return AVERROR_INVALIDDATA;
      96             :                 }
      97     2133702 :                 j     = scantable[i];
      98     2133702 :                 level = (level * qscale * quant_matrix[j]) >> 3;
      99     2133702 :                 level = (level ^ SHOW_SBITS(re, &a->gb, 1)) - SHOW_SBITS(re, &a->gb, 1);
     100     2133702 :                 LAST_SKIP_BITS(re, &a->gb, 1);
     101             :             } else {
     102             :                 /* escape */
     103       42898 :                 run = SHOW_UBITS(re, &a->gb, 6)+1; LAST_SKIP_BITS(re, &a->gb, 6);
     104       42898 :                 UPDATE_CACHE(re, &a->gb);
     105       42898 :                 level = SHOW_SBITS(re, &a->gb, 10); SKIP_BITS(re, &a->gb, 10);
     106       42898 :                 i += run;
     107       42898 :                 if (i > 63) {
     108           0 :                     av_log(a->avctx, AV_LOG_ERROR,
     109             :                            "ac-tex damaged at %d %d\n", a->mb_x, a->mb_y);
     110           0 :                     return AVERROR_INVALIDDATA;
     111             :                 }
     112       42898 :                 j = scantable[i];
     113       42898 :                 if (level < 0) {
     114       24818 :                     level = -level;
     115       24818 :                     level = (level * (unsigned)qscale * quant_matrix[j]) >> 3;
     116       24818 :                     level = (level - 1) | 1;
     117       24818 :                     level = -level;
     118             :                 } else {
     119       18080 :                     level = (level * (unsigned)qscale * quant_matrix[j]) >> 3;
     120       18080 :                     level = (level - 1) | 1;
     121             :                 }
     122             :             }
     123             : 
     124     2176600 :             block[j] = level;
     125             :         }
     126      285688 :         CLOSE_READER(re, &a->gb);
     127             :     }
     128      285688 :     a->block_last_index[n] = i;
     129      285688 :     return 0;
     130             : }
     131             : 
     132       47615 : static inline int decode_mb(MDECContext *a, int16_t block[6][64])
     133             : {
     134             :     int i, ret;
     135             :     static const int block_index[6] = { 5, 4, 0, 1, 2, 3 };
     136             : 
     137       47615 :     a->bdsp.clear_blocks(block[0]);
     138             : 
     139      333303 :     for (i = 0; i < 6; i++) {
     140      285689 :         if ((ret = mdec_decode_block_intra(a, block[block_index[i]],
     141             :                                            block_index[i])) < 0)
     142           1 :             return ret;
     143      285688 :         if (get_bits_left(&a->gb) < 0)
     144           0 :             return AVERROR_INVALIDDATA;
     145             :     }
     146       47614 :     return 0;
     147             : }
     148             : 
     149       47614 : static inline void idct_put(MDECContext *a, AVFrame *frame, int mb_x, int mb_y)
     150             : {
     151       47614 :     int16_t (*block)[64] = a->block;
     152       47614 :     int linesize = frame->linesize[0];
     153             : 
     154       47614 :     uint8_t *dest_y  = frame->data[0] + (mb_y * 16* linesize              ) + mb_x * 16;
     155       47614 :     uint8_t *dest_cb = frame->data[1] + (mb_y * 8 * frame->linesize[1]) + mb_x * 8;
     156       47614 :     uint8_t *dest_cr = frame->data[2] + (mb_y * 8 * frame->linesize[2]) + mb_x * 8;
     157             : 
     158       47614 :     a->idsp.idct_put(dest_y,                    linesize, block[0]);
     159       47614 :     a->idsp.idct_put(dest_y + 8,                linesize, block[1]);
     160       47614 :     a->idsp.idct_put(dest_y + 8 * linesize,     linesize, block[2]);
     161       47614 :     a->idsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]);
     162             : 
     163       47614 :     if (!(a->avctx->flags & AV_CODEC_FLAG_GRAY)) {
     164       47614 :         a->idsp.idct_put(dest_cb, frame->linesize[1], block[4]);
     165       47614 :         a->idsp.idct_put(dest_cr, frame->linesize[2], block[5]);
     166             :     }
     167       47614 : }
     168             : 
     169         194 : static int decode_frame(AVCodecContext *avctx,
     170             :                         void *data, int *got_frame,
     171             :                         AVPacket *avpkt)
     172             : {
     173         194 :     MDECContext * const a = avctx->priv_data;
     174         194 :     const uint8_t *buf    = avpkt->data;
     175         194 :     int buf_size          = avpkt->size;
     176         194 :     ThreadFrame frame     = { .f = data };
     177             :     int ret;
     178             : 
     179         194 :     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
     180           0 :         return ret;
     181         194 :     frame.f->pict_type = AV_PICTURE_TYPE_I;
     182         194 :     frame.f->key_frame = 1;
     183             : 
     184         194 :     av_fast_padded_malloc(&a->bitstream_buffer, &a->bitstream_buffer_size, buf_size);
     185         194 :     if (!a->bitstream_buffer)
     186           0 :         return AVERROR(ENOMEM);
     187         194 :     a->bbdsp.bswap16_buf((uint16_t *)a->bitstream_buffer, (uint16_t *)buf, (buf_size + 1) / 2);
     188         194 :     if ((ret = init_get_bits8(&a->gb, a->bitstream_buffer, buf_size)) < 0)
     189           0 :         return ret;
     190             : 
     191             :     /* skip over 4 preamble bytes in stream (typically 0xXX 0xXX 0x00 0x38) */
     192         194 :     skip_bits(&a->gb, 32);
     193             : 
     194         194 :     a->qscale  = get_bits(&a->gb, 16);
     195         194 :     a->version = get_bits(&a->gb, 16);
     196             : 
     197         194 :     a->last_dc[0] = a->last_dc[1] = a->last_dc[2] = 128;
     198             : 
     199        3932 :     for (a->mb_x = 0; a->mb_x < a->mb_width; a->mb_x++) {
     200       51353 :         for (a->mb_y = 0; a->mb_y < a->mb_height; a->mb_y++) {
     201       47615 :             if ((ret = decode_mb(a, a->block)) < 0)
     202           1 :                 return ret;
     203             : 
     204       47614 :             idct_put(a, frame.f, a->mb_x, a->mb_y);
     205             :         }
     206             :     }
     207             : 
     208         193 :     *got_frame = 1;
     209             : 
     210         193 :     return (get_bits_count(&a->gb) + 31) / 32 * 4;
     211             : }
     212             : 
     213           7 : static av_cold int decode_init(AVCodecContext *avctx)
     214             : {
     215           7 :     MDECContext * const a = avctx->priv_data;
     216             :     int i;
     217             : 
     218           7 :     a->mb_width  = (avctx->coded_width  + 15) / 16;
     219           7 :     a->mb_height = (avctx->coded_height + 15) / 16;
     220             : 
     221           7 :     a->avctx           = avctx;
     222             : 
     223           7 :     ff_blockdsp_init(&a->bdsp, avctx);
     224           7 :     ff_bswapdsp_init(&a->bbdsp);
     225           7 :     ff_idctdsp_init(&a->idsp, avctx);
     226           7 :     ff_mpeg12_init_vlcs();
     227           7 :     ff_init_scantable(a->idsp.idct_permutation, &a->scantable,
     228             :                       ff_zigzag_direct);
     229             : 
     230           7 :     avctx->pix_fmt  = AV_PIX_FMT_YUVJ420P;
     231           7 :     avctx->color_range = AVCOL_RANGE_JPEG;
     232             : 
     233             :     /* init q matrix */
     234         455 :     for (i = 0; i < 64; i++) {
     235         448 :         int j = a->idsp.idct_permutation[i];
     236             : 
     237         448 :         a->quant_matrix[j] = ff_mpeg1_default_intra_matrix[i];
     238             :     }
     239             : 
     240           7 :     return 0;
     241             : }
     242             : 
     243             : #if HAVE_THREADS
     244           0 : static av_cold int decode_init_thread_copy(AVCodecContext *avctx)
     245             : {
     246           0 :     MDECContext * const a = avctx->priv_data;
     247             : 
     248           0 :     a->avctx           = avctx;
     249             : 
     250           0 :     return 0;
     251             : }
     252             : #endif
     253             : 
     254           7 : static av_cold int decode_end(AVCodecContext *avctx)
     255             : {
     256           7 :     MDECContext * const a = avctx->priv_data;
     257             : 
     258           7 :     av_freep(&a->bitstream_buffer);
     259           7 :     a->bitstream_buffer_size = 0;
     260             : 
     261           7 :     return 0;
     262             : }
     263             : 
     264             : AVCodec ff_mdec_decoder = {
     265             :     .name             = "mdec",
     266             :     .long_name        = NULL_IF_CONFIG_SMALL("Sony PlayStation MDEC (Motion DECoder)"),
     267             :     .type             = AVMEDIA_TYPE_VIDEO,
     268             :     .id               = AV_CODEC_ID_MDEC,
     269             :     .priv_data_size   = sizeof(MDECContext),
     270             :     .init             = decode_init,
     271             :     .close            = decode_end,
     272             :     .decode           = decode_frame,
     273             :     .capabilities     = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
     274             :     .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy)
     275             : };

Generated by: LCOV version 1.13