LCOV - code coverage report
Current view: top level - libavcodec - mpeg12.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 135 144 93.8 %
Date: 2017-12-15 18:13:28 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * MPEG-1/2 decoder
       3             :  * Copyright (c) 2000, 2001 Fabrice Bellard
       4             :  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : /**
      24             :  * @file
      25             :  * MPEG-1/2 decoder
      26             :  */
      27             : 
      28             : #define UNCHECKED_BITSTREAM_READER 1
      29             : 
      30             : #include "libavutil/attributes.h"
      31             : #include "libavutil/avassert.h"
      32             : #include "libavutil/timecode.h"
      33             : 
      34             : #include "internal.h"
      35             : #include "avcodec.h"
      36             : #include "mpegvideo.h"
      37             : #include "error_resilience.h"
      38             : #include "mpeg12.h"
      39             : #include "mpeg12data.h"
      40             : #include "mpegvideodata.h"
      41             : #include "bytestream.h"
      42             : #include "thread.h"
      43             : 
      44             : uint8_t ff_mpeg12_static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3];
      45             : 
      46             : static const uint8_t table_mb_ptype[7][2] = {
      47             :     { 3, 5 }, // 0x01 MB_INTRA
      48             :     { 1, 2 }, // 0x02 MB_PAT
      49             :     { 1, 3 }, // 0x08 MB_FOR
      50             :     { 1, 1 }, // 0x0A MB_FOR|MB_PAT
      51             :     { 1, 6 }, // 0x11 MB_QUANT|MB_INTRA
      52             :     { 1, 5 }, // 0x12 MB_QUANT|MB_PAT
      53             :     { 2, 5 }, // 0x1A MB_QUANT|MB_FOR|MB_PAT
      54             : };
      55             : 
      56             : static const uint8_t table_mb_btype[11][2] = {
      57             :     { 3, 5 }, // 0x01 MB_INTRA
      58             :     { 2, 3 }, // 0x04 MB_BACK
      59             :     { 3, 3 }, // 0x06 MB_BACK|MB_PAT
      60             :     { 2, 4 }, // 0x08 MB_FOR
      61             :     { 3, 4 }, // 0x0A MB_FOR|MB_PAT
      62             :     { 2, 2 }, // 0x0C MB_FOR|MB_BACK
      63             :     { 3, 2 }, // 0x0E MB_FOR|MB_BACK|MB_PAT
      64             :     { 1, 6 }, // 0x11 MB_QUANT|MB_INTRA
      65             :     { 2, 6 }, // 0x16 MB_QUANT|MB_BACK|MB_PAT
      66             :     { 3, 6 }, // 0x1A MB_QUANT|MB_FOR|MB_PAT
      67             :     { 2, 5 }, // 0x1E MB_QUANT|MB_FOR|MB_BACK|MB_PAT
      68             : };
      69             : 
      70         232 : av_cold void ff_init_2d_vlc_rl(RLTable *rl, unsigned static_size, int flags)
      71             : {
      72             :     int i;
      73         232 :     VLC_TYPE table[680][2] = {{0}};
      74         232 :     VLC vlc = { .table = table, .table_allocated = static_size };
      75         232 :     av_assert0(static_size <= FF_ARRAY_ELEMS(table));
      76         232 :     init_vlc(&vlc, TEX_VLC_BITS, rl->n + 2, &rl->table_vlc[0][1], 4, 2, &rl->table_vlc[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC | flags);
      77             : 
      78      157290 :     for (i = 0; i < vlc.table_size; i++) {
      79      157058 :         int code = vlc.table[i][0];
      80      157058 :         int len  = vlc.table[i][1];
      81             :         int level, run;
      82             : 
      83      157058 :         if (len == 0) { // illegal code
      84        4862 :             run   = 65;
      85        4862 :             level = MAX_LEVEL;
      86      152196 :         } else if (len<0) { //more bits needed
      87        1505 :             run   = 0;
      88        1505 :             level = code;
      89             :         } else {
      90      150691 :             if (code == rl->n) { //esc
      91        1856 :                 run   = 65;
      92        1856 :                 level = 0;
      93      148835 :             } else if (code == rl->n+1) { //eob
      94       18464 :                 run   = 0;
      95       18464 :                 level = 127;
      96             :             } else {
      97      130371 :                 run   = rl->table_run  [code] + 1;
      98      130371 :                 level = rl->table_level[code];
      99             :             }
     100             :         }
     101      157058 :         rl->rl_vlc[0][i].len   = len;
     102      157058 :         rl->rl_vlc[0][i].level = level;
     103      157058 :         rl->rl_vlc[0][i].run   = run;
     104             :     }
     105         232 : }
     106             : 
     107         301 : av_cold void ff_mpeg12_common_init(MpegEncContext *s)
     108             : {
     109             : 
     110         301 :     s->y_dc_scale_table =
     111         301 :     s->c_dc_scale_table = ff_mpeg2_dc_scale_table[s->intra_dc_precision];
     112             : 
     113         301 : }
     114             : 
     115      398083 : void ff_mpeg1_clean_buffers(MpegEncContext *s)
     116             : {
     117      398083 :     s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
     118      398083 :     s->last_dc[1] = s->last_dc[0];
     119      398083 :     s->last_dc[2] = s->last_dc[0];
     120      398083 :     memset(s->last_mv, 0, sizeof(s->last_mv));
     121      398083 : }
     122             : 
     123             : 
     124             : /******************************************/
     125             : /* decoding */
     126             : 
     127             : VLC ff_mv_vlc;
     128             : 
     129             : VLC ff_dc_lum_vlc;
     130             : VLC ff_dc_chroma_vlc;
     131             : 
     132             : VLC ff_mbincr_vlc;
     133             : VLC ff_mb_ptype_vlc;
     134             : VLC ff_mb_btype_vlc;
     135             : VLC ff_mb_pat_vlc;
     136             : 
     137         266 : av_cold void ff_mpeg12_init_vlcs(void)
     138             : {
     139             :     static int done = 0;
     140             : 
     141         266 :     if (!done) {
     142         115 :         done = 1;
     143             : 
     144         115 :         INIT_VLC_STATIC(&ff_dc_lum_vlc, DC_VLC_BITS, 12,
     145             :                         ff_mpeg12_vlc_dc_lum_bits, 1, 1,
     146             :                         ff_mpeg12_vlc_dc_lum_code, 2, 2, 512);
     147         115 :         INIT_VLC_STATIC(&ff_dc_chroma_vlc,  DC_VLC_BITS, 12,
     148             :                         ff_mpeg12_vlc_dc_chroma_bits, 1, 1,
     149             :                         ff_mpeg12_vlc_dc_chroma_code, 2, 2, 514);
     150         115 :         INIT_VLC_STATIC(&ff_mv_vlc, MV_VLC_BITS, 17,
     151             :                         &ff_mpeg12_mbMotionVectorTable[0][1], 2, 1,
     152             :                         &ff_mpeg12_mbMotionVectorTable[0][0], 2, 1, 518);
     153         115 :         INIT_VLC_STATIC(&ff_mbincr_vlc, MBINCR_VLC_BITS, 36,
     154             :                         &ff_mpeg12_mbAddrIncrTable[0][1], 2, 1,
     155             :                         &ff_mpeg12_mbAddrIncrTable[0][0], 2, 1, 538);
     156         115 :         INIT_VLC_STATIC(&ff_mb_pat_vlc, MB_PAT_VLC_BITS, 64,
     157             :                         &ff_mpeg12_mbPatTable[0][1], 2, 1,
     158             :                         &ff_mpeg12_mbPatTable[0][0], 2, 1, 512);
     159             : 
     160         115 :         INIT_VLC_STATIC(&ff_mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7,
     161             :                         &table_mb_ptype[0][1], 2, 1,
     162             :                         &table_mb_ptype[0][0], 2, 1, 64);
     163         115 :         INIT_VLC_STATIC(&ff_mb_btype_vlc, MB_BTYPE_VLC_BITS, 11,
     164             :                         &table_mb_btype[0][1], 2, 1,
     165             :                         &table_mb_btype[0][0], 2, 1, 64);
     166         115 :         ff_rl_init(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]);
     167         115 :         ff_rl_init(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]);
     168             : 
     169         115 :         INIT_2D_VLC_RL(ff_rl_mpeg1, 680, 0);
     170         115 :         INIT_2D_VLC_RL(ff_rl_mpeg2, 674, 0);
     171             :     }
     172         266 : }
     173             : 
     174             : /**
     175             :  * Find the end of the current frame in the bitstream.
     176             :  * @return the position of the first byte of the next frame, or -1
     177             :  */
     178       44961 : int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size, AVCodecParserContext *s)
     179             : {
     180             :     int i;
     181       44961 :     uint32_t state = pc->state;
     182             : 
     183             :     /* EOF considered as end of frame */
     184       44961 :     if (buf_size == 0)
     185         305 :         return 0;
     186             : 
     187             : /*
     188             :  0  frame start         -> 1/4
     189             :  1  first_SEQEXT        -> 0/2
     190             :  2  first field start   -> 3/0
     191             :  3  second_SEQEXT       -> 2/0
     192             :  4  searching end
     193             : */
     194             : 
     195      249071 :     for (i = 0; i < buf_size; i++) {
     196             :         av_assert1(pc->frame_start_found >= 0 && pc->frame_start_found <= 4);
     197      209996 :         if (pc->frame_start_found & 1) {
     198       20790 :             if (state == EXT_START_CODE && (buf[i] & 0xF0) != 0x80)
     199        2094 :                 pc->frame_start_found--;
     200       18696 :             else if (state == EXT_START_CODE + 2) {
     201        6232 :                 if ((buf[i] & 3) == 3)
     202        3877 :                     pc->frame_start_found = 0;
     203             :                 else
     204        2355 :                     pc->frame_start_found = (pc->frame_start_found + 1) & 3;
     205             :             }
     206       20790 :             state++;
     207             :         } else {
     208      189206 :             i = avpriv_find_start_code(buf + i, buf + buf_size, &state) - buf - 1;
     209      189206 :             if (pc->frame_start_found == 0 && state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE) {
     210        6006 :                 i++;
     211        6006 :                 pc->frame_start_found = 4;
     212             :             }
     213      189206 :             if (state == SEQ_END_CODE) {
     214           8 :                 pc->frame_start_found = 0;
     215           8 :                 pc->state=-1;
     216           8 :                 return i+1;
     217             :             }
     218      189198 :             if (pc->frame_start_found == 2 && state == SEQ_START_CODE)
     219           0 :                 pc->frame_start_found = 0;
     220      189198 :             if (pc->frame_start_found  < 4 && state == EXT_START_CODE)
     221        8326 :                 pc->frame_start_found++;
     222      189198 :             if (pc->frame_start_found == 4 && (state & 0xFFFFFF00) == 0x100) {
     223      114289 :                 if (state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE) {
     224        5573 :                     pc->frame_start_found = 0;
     225        5573 :                     pc->state             = -1;
     226        5573 :                     return i - 3;
     227             :                 }
     228             :             }
     229      183625 :             if (pc->frame_start_found == 0 && s && state == PICTURE_START_CODE) {
     230        5967 :                 ff_fetch_timestamp(s, i - 3, 1, i > 3);
     231             :             }
     232             :         }
     233             :     }
     234       39075 :     pc->state = state;
     235       39075 :     return END_NOT_FOUND;
     236             : }
     237             : 
     238             : #define MAX_INDEX (64 - 1)
     239             : 
     240      188502 : int ff_mpeg1_decode_block_intra(GetBitContext *gb,
     241             :                                 const uint16_t *quant_matrix,
     242             :                                 uint8_t *const scantable, int last_dc[3],
     243             :                                 int16_t *block, int index, int qscale)
     244             : {
     245      188502 :     int dc, diff, i = 0, component;
     246      188502 :     RLTable *rl = &ff_rl_mpeg1;
     247             : 
     248             :     /* DC coefficient */
     249      188502 :     component = index <= 3 ? 0 : index - 4 + 1;
     250             : 
     251      188502 :     diff = decode_dc(gb, component);
     252      188502 :     if (diff >= 0xffff)
     253           0 :         return AVERROR_INVALIDDATA;
     254             : 
     255      188502 :     dc  = last_dc[component];
     256      188502 :     dc += diff;
     257      188502 :     last_dc[component] = dc;
     258             : 
     259      188502 :     block[0] = dc * quant_matrix[0];
     260             : 
     261             :     {
     262      188502 :         OPEN_READER(re, gb);
     263      188502 :         UPDATE_CACHE(re, gb);
     264      188502 :         if (((int32_t)GET_CACHE(re, gb)) <= (int32_t)0xBFFFFFFF)
     265       37329 :             goto end;
     266             : 
     267             :         /* now quantify & encode AC coefficients */
     268     1459305 :         while (1) {
     269             :             int level, run, j;
     270             : 
     271     1610478 :             GET_RL_VLC(level, run, re, gb, rl->rl_vlc[0],
     272             :                        TEX_VLC_BITS, 2, 0);
     273             : 
     274     1610478 :             if (level != 0) {
     275     1604847 :                 i += run;
     276     1604847 :                 if (i > MAX_INDEX)
     277           0 :                     break;
     278             : 
     279     1604847 :                 j = scantable[i];
     280     1604847 :                 level = (level * qscale * quant_matrix[j]) >> 4;
     281     1604847 :                 level = (level - 1) | 1;
     282     3209694 :                 level = (level ^ SHOW_SBITS(re, gb, 1)) -
     283     1604847 :                         SHOW_SBITS(re, gb, 1);
     284     1604847 :                 SKIP_BITS(re, gb, 1);
     285             :             } else {
     286             :                 /* escape */
     287        5631 :                 run = SHOW_UBITS(re, gb, 6) + 1;
     288        5631 :                 LAST_SKIP_BITS(re, gb, 6);
     289        5631 :                 UPDATE_CACHE(re, gb);
     290        5631 :                 level = SHOW_SBITS(re, gb, 8);
     291        5631 :                 SKIP_BITS(re, gb, 8);
     292             : 
     293        5631 :                 if (level == -128) {
     294           0 :                     level = SHOW_UBITS(re, gb, 8) - 256;
     295           0 :                     SKIP_BITS(re, gb, 8);
     296        5631 :                 } else if (level == 0) {
     297           0 :                     level = SHOW_UBITS(re, gb, 8);
     298           0 :                     SKIP_BITS(re, gb, 8);
     299             :                 }
     300             : 
     301        5631 :                 i += run;
     302        5631 :                 if (i > MAX_INDEX)
     303           0 :                     break;
     304             : 
     305        5631 :                 j = scantable[i];
     306        5631 :                 if (level < 0) {
     307        3191 :                     level = -level;
     308        3191 :                     level = (level * qscale * quant_matrix[j]) >> 4;
     309        3191 :                     level = (level - 1) | 1;
     310        3191 :                     level = -level;
     311             :                 } else {
     312        2440 :                     level = (level * qscale * quant_matrix[j]) >> 4;
     313        2440 :                     level = (level - 1) | 1;
     314             :                 }
     315             :             }
     316             : 
     317     1610478 :             block[j] = level;
     318     1610478 :             if (((int32_t)GET_CACHE(re, gb)) <= (int32_t)0xBFFFFFFF)
     319      151173 :                break;
     320             : 
     321     1459305 :             UPDATE_CACHE(re, gb);
     322             :         }
     323      188502 : end:
     324      188502 :         LAST_SKIP_BITS(re, gb, 2);
     325      188502 :         CLOSE_READER(re, gb);
     326             :     }
     327             : 
     328      188502 :     if (i > MAX_INDEX)
     329           0 :         i = AVERROR_INVALIDDATA;
     330             : 
     331      188502 :     return i;
     332             : }

Generated by: LCOV version 1.13