LCOV - code coverage report
Current view: top level - libavcodec - cavs_parser.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 35 36 97.2 %
Date: 2017-12-14 08:27:08 Functions: 2 2 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Chinese AVS video (AVS1-P2, JiZhun profile) parser.
       3             :  * Copyright (c) 2006  Stefan Gehrer <stefan.gehrer@gmx.de>
       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             :  * Chinese AVS video (AVS1-P2, JiZhun profile) parser
      25             :  * @author Stefan Gehrer <stefan.gehrer@gmx.de>
      26             :  */
      27             : 
      28             : #include "parser.h"
      29             : #include "cavs.h"
      30             : 
      31             : 
      32             : /**
      33             :  * Find the end of the current frame in the bitstream.
      34             :  * @return the position of the first byte of the next frame, or -1
      35             :  */
      36        2755 : static int cavs_find_frame_end(ParseContext *pc, const uint8_t *buf,
      37             :                                int buf_size) {
      38             :     int pic_found, i;
      39             :     uint32_t state;
      40             : 
      41        2755 :     pic_found= pc->frame_start_found;
      42        2755 :     state= pc->state;
      43             : 
      44        2755 :     i=0;
      45        2755 :     if(!pic_found){
      46        2218 :         for(i=0; i<buf_size; i++){
      47        2218 :             state= (state<<8) | buf[i];
      48        2218 :             if(state == PIC_I_START_CODE || state == PIC_PB_START_CODE){
      49         450 :                 i++;
      50         450 :                 pic_found=1;
      51         450 :                 break;
      52             :             }
      53             :         }
      54             :     }
      55             : 
      56        2755 :     if(pic_found){
      57             :         /* EOF considered as end of frame */
      58        2755 :         if (buf_size == 0)
      59           2 :             return 0;
      60     4633398 :         for(; i<buf_size; i++){
      61     4631091 :             state= (state<<8) | buf[i];
      62     4631091 :             if((state&0xFFFFFF00) == 0x100){
      63         446 :                 if(state > SLICE_MAX_START_CODE){
      64         446 :                     pc->frame_start_found=0;
      65         446 :                     pc->state=-1;
      66         446 :                     return i-3;
      67             :                 }
      68             :             }
      69             :         }
      70             :     }
      71        2307 :     pc->frame_start_found= pic_found;
      72        2307 :     pc->state= state;
      73        2307 :     return END_NOT_FOUND;
      74             : }
      75             : 
      76        2755 : static int cavsvideo_parse(AVCodecParserContext *s,
      77             :                            AVCodecContext *avctx,
      78             :                            const uint8_t **poutbuf, int *poutbuf_size,
      79             :                            const uint8_t *buf, int buf_size)
      80             : {
      81        2755 :     ParseContext *pc = s->priv_data;
      82             :     int next;
      83             : 
      84        2755 :     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
      85           0 :         next= buf_size;
      86             :     }else{
      87        2755 :         next= cavs_find_frame_end(pc, buf, buf_size);
      88             : 
      89        2755 :         if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
      90        2307 :             *poutbuf = NULL;
      91        2307 :             *poutbuf_size = 0;
      92        2307 :             return buf_size;
      93             :         }
      94             :     }
      95         448 :     *poutbuf = buf;
      96         448 :     *poutbuf_size = buf_size;
      97         448 :     return next;
      98             : }
      99             : 
     100             : AVCodecParser ff_cavsvideo_parser = {
     101             :     .codec_ids      = { AV_CODEC_ID_CAVS },
     102             :     .priv_data_size = sizeof(ParseContext),
     103             :     .parser_parse   = cavsvideo_parse,
     104             :     .parser_close   = ff_parse_close,
     105             :     .split          = ff_mpeg4video_split,
     106             : };

Generated by: LCOV version 1.13