LCOV - code coverage report
Current view: directory - media/libtheora/lib - state.c (source / functions) Found Hit Coverage
Test: app.info Lines: 473 0 0.0 %
Date: 2012-06-02 Functions: 31 0 0.0 %

       1                 : /********************************************************************
       2                 :  *                                                                  *
       3                 :  * THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE.   *
       4                 :  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
       5                 :  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
       6                 :  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
       7                 :  *                                                                  *
       8                 :  * THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2009                *
       9                 :  * by the Xiph.Org Foundation and contributors http://www.xiph.org/ *
      10                 :  *                                                                  *
      11                 :  ********************************************************************
      12                 : 
      13                 :   function:
      14                 :     last mod: $Id: state.c 17576 2010-10-29 01:07:51Z tterribe $
      15                 : 
      16                 :  ********************************************************************/
      17                 : 
      18                 : #include <stdlib.h>
      19                 : #include <string.h>
      20                 : #include "state.h"
      21                 : #if defined(OC_DUMP_IMAGES)
      22                 : # include <stdio.h>
      23                 : # include "png.h"
      24                 : #endif
      25                 : 
      26                 : /*The function used to fill in the chroma plane motion vectors for a macro
      27                 :    block when 4 different motion vectors are specified in the luma plane.
      28                 :   This version is for use with chroma decimated in the X and Y directions
      29                 :    (4:2:0).
      30                 :   _cbmvs: The chroma block-level motion vectors to fill in.
      31                 :   _lbmvs: The luma block-level motion vectors.*/
      32               0 : static void oc_set_chroma_mvs00(oc_mv _cbmvs[4],const oc_mv _lbmvs[4]){
      33                 :   int dx;
      34                 :   int dy;
      35               0 :   dx=OC_MV_X(_lbmvs[0])+OC_MV_X(_lbmvs[1])
      36               0 :    +OC_MV_X(_lbmvs[2])+OC_MV_X(_lbmvs[3]);
      37               0 :   dy=OC_MV_Y(_lbmvs[0])+OC_MV_Y(_lbmvs[1])
      38               0 :    +OC_MV_Y(_lbmvs[2])+OC_MV_Y(_lbmvs[3]);
      39               0 :   _cbmvs[0]=OC_MV(OC_DIV_ROUND_POW2(dx,2,2),OC_DIV_ROUND_POW2(dy,2,2));
      40               0 : }
      41                 : 
      42                 : /*The function used to fill in the chroma plane motion vectors for a macro
      43                 :    block when 4 different motion vectors are specified in the luma plane.
      44                 :   This version is for use with chroma decimated in the Y direction.
      45                 :   _cbmvs: The chroma block-level motion vectors to fill in.
      46                 :   _lbmvs: The luma block-level motion vectors.*/
      47               0 : static void oc_set_chroma_mvs01(oc_mv _cbmvs[4],const oc_mv _lbmvs[4]){
      48                 :   int dx;
      49                 :   int dy;
      50               0 :   dx=OC_MV_X(_lbmvs[0])+OC_MV_X(_lbmvs[2]);
      51               0 :   dy=OC_MV_Y(_lbmvs[0])+OC_MV_Y(_lbmvs[2]);
      52               0 :   _cbmvs[0]=OC_MV(OC_DIV_ROUND_POW2(dx,1,1),OC_DIV_ROUND_POW2(dy,1,1));
      53               0 :   dx=OC_MV_X(_lbmvs[1])+OC_MV_X(_lbmvs[3]);
      54               0 :   dy=OC_MV_Y(_lbmvs[1])+OC_MV_Y(_lbmvs[3]);
      55               0 :   _cbmvs[1]=OC_MV(OC_DIV_ROUND_POW2(dx,1,1),OC_DIV_ROUND_POW2(dy,1,1));
      56               0 : }
      57                 : 
      58                 : /*The function used to fill in the chroma plane motion vectors for a macro
      59                 :    block when 4 different motion vectors are specified in the luma plane.
      60                 :   This version is for use with chroma decimated in the X direction (4:2:2).
      61                 :   _cbmvs: The chroma block-level motion vectors to fill in.
      62                 :   _lbmvs: The luma block-level motion vectors.*/
      63               0 : static void oc_set_chroma_mvs10(oc_mv _cbmvs[4],const oc_mv _lbmvs[4]){
      64                 :   int dx;
      65                 :   int dy;
      66               0 :   dx=OC_MV_X(_lbmvs[0])+OC_MV_X(_lbmvs[1]);
      67               0 :   dy=OC_MV_Y(_lbmvs[0])+OC_MV_Y(_lbmvs[1]);
      68               0 :   _cbmvs[0]=OC_MV(OC_DIV_ROUND_POW2(dx,1,1),OC_DIV_ROUND_POW2(dy,1,1));
      69               0 :   dx=OC_MV_X(_lbmvs[2])+OC_MV_X(_lbmvs[3]);
      70               0 :   dy=OC_MV_Y(_lbmvs[2])+OC_MV_Y(_lbmvs[3]);
      71               0 :   _cbmvs[2]=OC_MV(OC_DIV_ROUND_POW2(dx,1,1),OC_DIV_ROUND_POW2(dy,1,1));
      72               0 : }
      73                 : 
      74                 : /*The function used to fill in the chroma plane motion vectors for a macro
      75                 :    block when 4 different motion vectors are specified in the luma plane.
      76                 :   This version is for use with no chroma decimation (4:4:4).
      77                 :   _cbmvs: The chroma block-level motion vectors to fill in.
      78                 :   _lmbmv: The luma macro-block level motion vector to fill in for use in
      79                 :            prediction.
      80                 :   _lbmvs: The luma block-level motion vectors.*/
      81               0 : static void oc_set_chroma_mvs11(oc_mv _cbmvs[4],const oc_mv _lbmvs[4]){
      82               0 :   _cbmvs[0]=_lbmvs[0];
      83               0 :   _cbmvs[1]=_lbmvs[1];
      84               0 :   _cbmvs[2]=_lbmvs[2];
      85               0 :   _cbmvs[3]=_lbmvs[3];
      86               0 : }
      87                 : 
      88                 : /*A table of functions used to fill in the chroma plane motion vectors for a
      89                 :    macro block when 4 different motion vectors are specified in the luma
      90                 :    plane.*/
      91                 : const oc_set_chroma_mvs_func OC_SET_CHROMA_MVS_TABLE[TH_PF_NFORMATS]={
      92                 :   (oc_set_chroma_mvs_func)oc_set_chroma_mvs00,
      93                 :   (oc_set_chroma_mvs_func)oc_set_chroma_mvs01,
      94                 :   (oc_set_chroma_mvs_func)oc_set_chroma_mvs10,
      95                 :   (oc_set_chroma_mvs_func)oc_set_chroma_mvs11
      96                 : };
      97                 : 
      98                 : 
      99                 : 
     100                 : /*Returns the fragment index of the top-left block in a macro block.
     101                 :   This can be used to test whether or not the whole macro block is valid.
     102                 :   _sb_map: The super block map.
     103                 :   _quadi:  The quadrant number.
     104                 :   Return: The index of the fragment of the upper left block in the macro
     105                 :    block, or -1 if the block lies outside the coded frame.*/
     106               0 : static ptrdiff_t oc_sb_quad_top_left_frag(oc_sb_map_quad _sb_map[4],int _quadi){
     107                 :   /*It so happens that under the Hilbert curve ordering described below, the
     108                 :      upper-left block in each macro block is at index 0, except in macro block
     109                 :      3, where it is at index 2.*/
     110               0 :   return _sb_map[_quadi][_quadi&_quadi<<1];
     111                 : }
     112                 : 
     113                 : /*Fills in the mapping from block positions to fragment numbers for a single
     114                 :    color plane.
     115                 :   This function also fills in the "valid" flag of each quadrant in the super
     116                 :    block flags.
     117                 :   _sb_maps:  The array of super block maps for the color plane.
     118                 :   _sb_flags: The array of super block flags for the color plane.
     119                 :   _frag0:    The index of the first fragment in the plane.
     120                 :   _hfrags:   The number of horizontal fragments in a coded frame.
     121                 :   _vfrags:   The number of vertical fragments in a coded frame.*/
     122               0 : static void oc_sb_create_plane_mapping(oc_sb_map _sb_maps[],
     123                 :  oc_sb_flags _sb_flags[],ptrdiff_t _frag0,int _hfrags,int _vfrags){
     124                 :   /*Contains the (macro_block,block) indices for a 4x4 grid of
     125                 :      fragments.
     126                 :     The pattern is a 4x4 Hilbert space-filling curve.
     127                 :     A Hilbert curve has the nice property that as the curve grows larger, its
     128                 :      fractal dimension approaches 2.
     129                 :     The intuition is that nearby blocks in the curve are also close spatially,
     130                 :      with the previous element always an immediate neighbor, so that runs of
     131                 :      blocks should be well correlated.*/
     132                 :   static const int SB_MAP[4][4][2]={
     133                 :     {{0,0},{0,1},{3,2},{3,3}},
     134                 :     {{0,3},{0,2},{3,1},{3,0}},
     135                 :     {{1,0},{1,3},{2,0},{2,3}},
     136                 :     {{1,1},{1,2},{2,1},{2,2}}
     137                 :   };
     138                 :   ptrdiff_t  yfrag;
     139                 :   unsigned   sbi;
     140                 :   int        y;
     141               0 :   sbi=0;
     142               0 :   yfrag=_frag0;
     143               0 :   for(y=0;;y+=4){
     144                 :     int imax;
     145                 :     int x;
     146                 :     /*Figure out how many columns of blocks in this super block lie within the
     147                 :        image.*/
     148               0 :     imax=_vfrags-y;
     149               0 :     if(imax>4)imax=4;
     150               0 :     else if(imax<=0)break;
     151               0 :     for(x=0;;x+=4,sbi++){
     152                 :       ptrdiff_t xfrag;
     153                 :       int       jmax;
     154                 :       int       quadi;
     155                 :       int       i;
     156                 :       /*Figure out how many rows of blocks in this super block lie within the
     157                 :          image.*/
     158               0 :       jmax=_hfrags-x;
     159               0 :       if(jmax>4)jmax=4;
     160               0 :       else if(jmax<=0)break;
     161                 :       /*By default, set all fragment indices to -1.*/
     162               0 :       memset(_sb_maps[sbi],0xFF,sizeof(_sb_maps[sbi]));
     163                 :       /*Fill in the fragment map for this super block.*/
     164               0 :       xfrag=yfrag+x;
     165               0 :       for(i=0;i<imax;i++){
     166                 :         int j;
     167               0 :         for(j=0;j<jmax;j++){
     168               0 :           _sb_maps[sbi][SB_MAP[i][j][0]][SB_MAP[i][j][1]]=xfrag+j;
     169                 :         }
     170               0 :         xfrag+=_hfrags;
     171                 :       }
     172                 :       /*Mark which quadrants of this super block lie within the image.*/
     173               0 :       for(quadi=0;quadi<4;quadi++){
     174               0 :         _sb_flags[sbi].quad_valid|=
     175               0 :          (oc_sb_quad_top_left_frag(_sb_maps[sbi],quadi)>=0)<<quadi;
     176                 :       }
     177               0 :     }
     178               0 :     yfrag+=_hfrags<<2;
     179               0 :   }
     180               0 : }
     181                 : 
     182                 : /*Fills in the Y plane fragment map for a macro block given the fragment
     183                 :    coordinates of its upper-left hand corner.
     184                 :   _mb_map:    The macro block map to fill.
     185                 :   _fplane: The description of the Y plane.
     186                 :   _xfrag0: The X location of the upper-left hand fragment in the luma plane.
     187                 :   _yfrag0: The Y location of the upper-left hand fragment in the luma plane.*/
     188               0 : static void oc_mb_fill_ymapping(oc_mb_map_plane _mb_map[3],
     189                 :  const oc_fragment_plane *_fplane,int _xfrag0,int _yfrag0){
     190                 :   int i;
     191                 :   int j;
     192               0 :   for(i=0;i<2;i++)for(j=0;j<2;j++){
     193               0 :     _mb_map[0][i<<1|j]=(_yfrag0+i)*(ptrdiff_t)_fplane->nhfrags+_xfrag0+j;
     194                 :   }
     195               0 : }
     196                 : 
     197                 : /*Fills in the chroma plane fragment maps for a macro block.
     198                 :   This version is for use with chroma decimated in the X and Y directions
     199                 :    (4:2:0).
     200                 :   _mb_map:  The macro block map to fill.
     201                 :   _fplanes: The descriptions of the fragment planes.
     202                 :   _xfrag0:  The X location of the upper-left hand fragment in the luma plane.
     203                 :   _yfrag0:  The Y location of the upper-left hand fragment in the luma plane.*/
     204               0 : static void oc_mb_fill_cmapping00(oc_mb_map_plane _mb_map[3],
     205                 :  const oc_fragment_plane _fplanes[3],int _xfrag0,int _yfrag0){
     206                 :   ptrdiff_t fragi;
     207               0 :   _xfrag0>>=1;
     208               0 :   _yfrag0>>=1;
     209               0 :   fragi=_yfrag0*(ptrdiff_t)_fplanes[1].nhfrags+_xfrag0;
     210               0 :   _mb_map[1][0]=fragi+_fplanes[1].froffset;
     211               0 :   _mb_map[2][0]=fragi+_fplanes[2].froffset;
     212               0 : }
     213                 : 
     214                 : /*Fills in the chroma plane fragment maps for a macro block.
     215                 :   This version is for use with chroma decimated in the Y direction.
     216                 :   _mb_map:  The macro block map to fill.
     217                 :   _fplanes: The descriptions of the fragment planes.
     218                 :   _xfrag0:  The X location of the upper-left hand fragment in the luma plane.
     219                 :   _yfrag0:  The Y location of the upper-left hand fragment in the luma plane.*/
     220               0 : static void oc_mb_fill_cmapping01(oc_mb_map_plane _mb_map[3],
     221                 :  const oc_fragment_plane _fplanes[3],int _xfrag0,int _yfrag0){
     222                 :   ptrdiff_t fragi;
     223                 :   int       j;
     224               0 :   _yfrag0>>=1;
     225               0 :   fragi=_yfrag0*(ptrdiff_t)_fplanes[1].nhfrags+_xfrag0;
     226               0 :   for(j=0;j<2;j++){
     227               0 :     _mb_map[1][j]=fragi+_fplanes[1].froffset;
     228               0 :     _mb_map[2][j]=fragi+_fplanes[2].froffset;
     229               0 :     fragi++;
     230                 :   }
     231               0 : }
     232                 : 
     233                 : /*Fills in the chroma plane fragment maps for a macro block.
     234                 :   This version is for use with chroma decimated in the X direction (4:2:2).
     235                 :   _mb_map:  The macro block map to fill.
     236                 :   _fplanes: The descriptions of the fragment planes.
     237                 :   _xfrag0:  The X location of the upper-left hand fragment in the luma plane.
     238                 :   _yfrag0:  The Y location of the upper-left hand fragment in the luma plane.*/
     239               0 : static void oc_mb_fill_cmapping10(oc_mb_map_plane _mb_map[3],
     240                 :  const oc_fragment_plane _fplanes[3],int _xfrag0,int _yfrag0){
     241                 :   ptrdiff_t fragi;
     242                 :   int       i;
     243               0 :   _xfrag0>>=1;
     244               0 :   fragi=_yfrag0*(ptrdiff_t)_fplanes[1].nhfrags+_xfrag0;
     245               0 :   for(i=0;i<2;i++){
     246               0 :     _mb_map[1][i<<1]=fragi+_fplanes[1].froffset;
     247               0 :     _mb_map[2][i<<1]=fragi+_fplanes[2].froffset;
     248               0 :     fragi+=_fplanes[1].nhfrags;
     249                 :   }
     250               0 : }
     251                 : 
     252                 : /*Fills in the chroma plane fragment maps for a macro block.
     253                 :   This version is for use with no chroma decimation (4:4:4).
     254                 :   This uses the already filled-in luma plane values.
     255                 :   _mb_map:  The macro block map to fill.
     256                 :   _fplanes: The descriptions of the fragment planes.*/
     257               0 : static void oc_mb_fill_cmapping11(oc_mb_map_plane _mb_map[3],
     258                 :  const oc_fragment_plane _fplanes[3]){
     259                 :   int k;
     260               0 :   for(k=0;k<4;k++){
     261               0 :     _mb_map[1][k]=_mb_map[0][k]+_fplanes[1].froffset;
     262               0 :     _mb_map[2][k]=_mb_map[0][k]+_fplanes[2].froffset;
     263                 :   }
     264               0 : }
     265                 : 
     266                 : /*The function type used to fill in the chroma plane fragment maps for a
     267                 :    macro block.
     268                 :   _mb_map:  The macro block map to fill.
     269                 :   _fplanes: The descriptions of the fragment planes.
     270                 :   _xfrag0:  The X location of the upper-left hand fragment in the luma plane.
     271                 :   _yfrag0:  The Y location of the upper-left hand fragment in the luma plane.*/
     272                 : typedef void (*oc_mb_fill_cmapping_func)(oc_mb_map_plane _mb_map[3],
     273                 :  const oc_fragment_plane _fplanes[3],int _xfrag0,int _yfrag0);
     274                 : 
     275                 : /*A table of functions used to fill in the chroma plane fragment maps for a
     276                 :    macro block for each type of chrominance decimation.*/
     277                 : static const oc_mb_fill_cmapping_func OC_MB_FILL_CMAPPING_TABLE[4]={
     278                 :   oc_mb_fill_cmapping00,
     279                 :   oc_mb_fill_cmapping01,
     280                 :   oc_mb_fill_cmapping10,
     281                 :   (oc_mb_fill_cmapping_func)oc_mb_fill_cmapping11
     282                 : };
     283                 : 
     284                 : /*Fills in the mapping from macro blocks to their corresponding fragment
     285                 :    numbers in each plane.
     286                 :   _mb_maps:   The list of macro block maps.
     287                 :   _mb_modes:  The list of macro block modes; macro blocks completely outside
     288                 :                the coded region are marked invalid.
     289                 :   _fplanes:   The descriptions of the fragment planes.
     290                 :   _pixel_fmt: The chroma decimation type.*/
     291               0 : static void oc_mb_create_mapping(oc_mb_map _mb_maps[],
     292                 :  signed char _mb_modes[],const oc_fragment_plane _fplanes[3],int _pixel_fmt){
     293                 :   oc_mb_fill_cmapping_func  mb_fill_cmapping;
     294                 :   unsigned                  sbi;
     295                 :   int                       y;
     296               0 :   mb_fill_cmapping=OC_MB_FILL_CMAPPING_TABLE[_pixel_fmt];
     297                 :   /*Loop through the luma plane super blocks.*/
     298               0 :   for(sbi=y=0;y<_fplanes[0].nvfrags;y+=4){
     299                 :     int x;
     300               0 :     for(x=0;x<_fplanes[0].nhfrags;x+=4,sbi++){
     301                 :       int ymb;
     302                 :       /*Loop through the macro blocks in each super block in display order.*/
     303               0 :       for(ymb=0;ymb<2;ymb++){
     304                 :         int xmb;
     305               0 :         for(xmb=0;xmb<2;xmb++){
     306                 :           unsigned mbi;
     307                 :           int      mbx;
     308                 :           int      mby;
     309               0 :           mbi=sbi<<2|OC_MB_MAP[ymb][xmb];
     310               0 :           mbx=x|xmb<<1;
     311               0 :           mby=y|ymb<<1;
     312                 :           /*Initialize fragment indices to -1.*/
     313               0 :           memset(_mb_maps[mbi],0xFF,sizeof(_mb_maps[mbi]));
     314                 :           /*Make sure this macro block is within the encoded region.*/
     315               0 :           if(mbx>=_fplanes[0].nhfrags||mby>=_fplanes[0].nvfrags){
     316               0 :             _mb_modes[mbi]=OC_MODE_INVALID;
     317               0 :             continue;
     318                 :           }
     319                 :           /*Fill in the fragment indices for the luma plane.*/
     320               0 :           oc_mb_fill_ymapping(_mb_maps[mbi],_fplanes,mbx,mby);
     321                 :           /*Fill in the fragment indices for the chroma planes.*/
     322               0 :           (*mb_fill_cmapping)(_mb_maps[mbi],_fplanes,mbx,mby);
     323                 :         }
     324                 :       }
     325                 :     }
     326                 :   }
     327               0 : }
     328                 : 
     329                 : /*Marks the fragments which fall all or partially outside the displayable
     330                 :    region of the frame.
     331                 :   _state: The Theora state containing the fragments to be marked.*/
     332               0 : static void oc_state_border_init(oc_theora_state *_state){
     333                 :   oc_fragment       *frag;
     334                 :   oc_fragment       *yfrag_end;
     335                 :   oc_fragment       *xfrag_end;
     336                 :   oc_fragment_plane *fplane;
     337                 :   int                crop_x0;
     338                 :   int                crop_y0;
     339                 :   int                crop_xf;
     340                 :   int                crop_yf;
     341                 :   int                pli;
     342                 :   int                y;
     343                 :   int                x;
     344                 :   /*The method we use here is slow, but the code is dead simple and handles
     345                 :      all the special cases easily.
     346                 :     We only ever need to do it once.*/
     347                 :   /*Loop through the fragments, marking those completely outside the
     348                 :      displayable region and constructing a border mask for those that straddle
     349                 :      the border.*/
     350               0 :   _state->nborders=0;
     351               0 :   yfrag_end=frag=_state->frags;
     352               0 :   for(pli=0;pli<3;pli++){
     353               0 :     fplane=_state->fplanes+pli;
     354                 :     /*Set up the cropping rectangle for this plane.*/
     355               0 :     crop_x0=_state->info.pic_x;
     356               0 :     crop_xf=_state->info.pic_x+_state->info.pic_width;
     357               0 :     crop_y0=_state->info.pic_y;
     358               0 :     crop_yf=_state->info.pic_y+_state->info.pic_height;
     359               0 :     if(pli>0){
     360               0 :       if(!(_state->info.pixel_fmt&1)){
     361               0 :         crop_x0=crop_x0>>1;
     362               0 :         crop_xf=crop_xf+1>>1;
     363                 :       }
     364               0 :       if(!(_state->info.pixel_fmt&2)){
     365               0 :         crop_y0=crop_y0>>1;
     366               0 :         crop_yf=crop_yf+1>>1;
     367                 :       }
     368                 :     }
     369               0 :     y=0;
     370               0 :     for(yfrag_end+=fplane->nfrags;frag<yfrag_end;y+=8){
     371               0 :       x=0;
     372               0 :       for(xfrag_end=frag+fplane->nhfrags;frag<xfrag_end;frag++,x+=8){
     373                 :         /*First check to see if this fragment is completely outside the
     374                 :            displayable region.*/
     375                 :         /*Note the special checks for an empty cropping rectangle.
     376                 :           This guarantees that if we count a fragment as straddling the
     377                 :            border below, at least one pixel in the fragment will be inside
     378                 :            the displayable region.*/
     379               0 :         if(x+8<=crop_x0||crop_xf<=x||y+8<=crop_y0||crop_yf<=y||
     380               0 :          crop_x0>=crop_xf||crop_y0>=crop_yf){
     381               0 :           frag->invalid=1;
     382                 :         }
     383                 :         /*Otherwise, check to see if it straddles the border.*/
     384               0 :         else if(x<crop_x0&&crop_x0<x+8||x<crop_xf&&crop_xf<x+8||
     385               0 :          y<crop_y0&&crop_y0<y+8||y<crop_yf&&crop_yf<y+8){
     386                 :           ogg_int64_t mask;
     387                 :           int         npixels;
     388                 :           int         i;
     389               0 :           mask=npixels=0;
     390               0 :           for(i=0;i<8;i++){
     391                 :             int j;
     392               0 :             for(j=0;j<8;j++){
     393               0 :               if(x+j>=crop_x0&&x+j<crop_xf&&y+i>=crop_y0&&y+i<crop_yf){
     394               0 :                 mask|=(ogg_int64_t)1<<(i<<3|j);
     395               0 :                 npixels++;
     396                 :               }
     397                 :             }
     398                 :           }
     399                 :           /*Search the fragment array for border info with the same pattern.
     400                 :             In general, there will be at most 8 different patterns (per
     401                 :              plane).*/
     402               0 :           for(i=0;;i++){
     403               0 :             if(i>=_state->nborders){
     404               0 :               _state->nborders++;
     405               0 :               _state->borders[i].mask=mask;
     406               0 :               _state->borders[i].npixels=npixels;
     407                 :             }
     408               0 :             else if(_state->borders[i].mask!=mask)continue;
     409               0 :             frag->borderi=i;
     410                 :             break;
     411               0 :           }
     412                 :         }
     413               0 :         else frag->borderi=-1;
     414                 :       }
     415                 :     }
     416                 :   }
     417               0 : }
     418                 : 
     419               0 : static int oc_state_frarray_init(oc_theora_state *_state){
     420                 :   int       yhfrags;
     421                 :   int       yvfrags;
     422                 :   int       chfrags;
     423                 :   int       cvfrags;
     424                 :   ptrdiff_t yfrags;
     425                 :   ptrdiff_t cfrags;
     426                 :   ptrdiff_t nfrags;
     427                 :   unsigned  yhsbs;
     428                 :   unsigned  yvsbs;
     429                 :   unsigned  chsbs;
     430                 :   unsigned  cvsbs;
     431                 :   unsigned  ysbs;
     432                 :   unsigned  csbs;
     433                 :   unsigned  nsbs;
     434                 :   size_t    nmbs;
     435                 :   int       hdec;
     436                 :   int       vdec;
     437                 :   int       pli;
     438                 :   /*Figure out the number of fragments in each plane.*/
     439                 :   /*These parameters have already been validated to be multiples of 16.*/
     440               0 :   yhfrags=_state->info.frame_width>>3;
     441               0 :   yvfrags=_state->info.frame_height>>3;
     442               0 :   hdec=!(_state->info.pixel_fmt&1);
     443               0 :   vdec=!(_state->info.pixel_fmt&2);
     444               0 :   chfrags=yhfrags+hdec>>hdec;
     445               0 :   cvfrags=yvfrags+vdec>>vdec;
     446               0 :   yfrags=yhfrags*(ptrdiff_t)yvfrags;
     447               0 :   cfrags=chfrags*(ptrdiff_t)cvfrags;
     448               0 :   nfrags=yfrags+2*cfrags;
     449                 :   /*Figure out the number of super blocks in each plane.*/
     450               0 :   yhsbs=yhfrags+3>>2;
     451               0 :   yvsbs=yvfrags+3>>2;
     452               0 :   chsbs=chfrags+3>>2;
     453               0 :   cvsbs=cvfrags+3>>2;
     454               0 :   ysbs=yhsbs*yvsbs;
     455               0 :   csbs=chsbs*cvsbs;
     456               0 :   nsbs=ysbs+2*csbs;
     457               0 :   nmbs=(size_t)ysbs<<2;
     458                 :   /*Check for overflow.
     459                 :     We support the ridiculous upper limits of the specification (1048560 by
     460                 :      1048560, or 3 TB frames) if the target architecture has 64-bit pointers,
     461                 :      but for those with 32-bit pointers (or smaller!) we have to check.
     462                 :     If the caller wants to prevent denial-of-service by imposing a more
     463                 :      reasonable upper limit on the size of attempted allocations, they must do
     464                 :      so themselves; we have no platform independent way to determine how much
     465                 :      system memory there is nor an application-independent way to decide what a
     466                 :      "reasonable" allocation is.*/
     467               0 :   if(yfrags/yhfrags!=yvfrags||2*cfrags<cfrags||nfrags<yfrags||
     468               0 :    ysbs/yhsbs!=yvsbs||2*csbs<csbs||nsbs<ysbs||nmbs>>2!=ysbs){
     469               0 :     return TH_EIMPL;
     470                 :   }
     471                 :   /*Initialize the fragment array.*/
     472               0 :   _state->fplanes[0].nhfrags=yhfrags;
     473               0 :   _state->fplanes[0].nvfrags=yvfrags;
     474               0 :   _state->fplanes[0].froffset=0;
     475               0 :   _state->fplanes[0].nfrags=yfrags;
     476               0 :   _state->fplanes[0].nhsbs=yhsbs;
     477               0 :   _state->fplanes[0].nvsbs=yvsbs;
     478               0 :   _state->fplanes[0].sboffset=0;
     479               0 :   _state->fplanes[0].nsbs=ysbs;
     480               0 :   _state->fplanes[1].nhfrags=_state->fplanes[2].nhfrags=chfrags;
     481               0 :   _state->fplanes[1].nvfrags=_state->fplanes[2].nvfrags=cvfrags;
     482               0 :   _state->fplanes[1].froffset=yfrags;
     483               0 :   _state->fplanes[2].froffset=yfrags+cfrags;
     484               0 :   _state->fplanes[1].nfrags=_state->fplanes[2].nfrags=cfrags;
     485               0 :   _state->fplanes[1].nhsbs=_state->fplanes[2].nhsbs=chsbs;
     486               0 :   _state->fplanes[1].nvsbs=_state->fplanes[2].nvsbs=cvsbs;
     487               0 :   _state->fplanes[1].sboffset=ysbs;
     488               0 :   _state->fplanes[2].sboffset=ysbs+csbs;
     489               0 :   _state->fplanes[1].nsbs=_state->fplanes[2].nsbs=csbs;
     490               0 :   _state->nfrags=nfrags;
     491               0 :   _state->frags=_ogg_calloc(nfrags,sizeof(*_state->frags));
     492               0 :   _state->frag_mvs=_ogg_malloc(nfrags*sizeof(*_state->frag_mvs));
     493               0 :   _state->nsbs=nsbs;
     494               0 :   _state->sb_maps=_ogg_malloc(nsbs*sizeof(*_state->sb_maps));
     495               0 :   _state->sb_flags=_ogg_calloc(nsbs,sizeof(*_state->sb_flags));
     496               0 :   _state->nhmbs=yhsbs<<1;
     497               0 :   _state->nvmbs=yvsbs<<1;
     498               0 :   _state->nmbs=nmbs;
     499               0 :   _state->mb_maps=_ogg_calloc(nmbs,sizeof(*_state->mb_maps));
     500               0 :   _state->mb_modes=_ogg_calloc(nmbs,sizeof(*_state->mb_modes));
     501               0 :   _state->coded_fragis=_ogg_malloc(nfrags*sizeof(*_state->coded_fragis));
     502               0 :   if(_state->frags==NULL||_state->frag_mvs==NULL||_state->sb_maps==NULL||
     503               0 :    _state->sb_flags==NULL||_state->mb_maps==NULL||_state->mb_modes==NULL||
     504               0 :    _state->coded_fragis==NULL){
     505               0 :     return TH_EFAULT;
     506                 :   }
     507                 :   /*Create the mapping from super blocks to fragments.*/
     508               0 :   for(pli=0;pli<3;pli++){
     509                 :     oc_fragment_plane *fplane;
     510               0 :     fplane=_state->fplanes+pli;
     511               0 :     oc_sb_create_plane_mapping(_state->sb_maps+fplane->sboffset,
     512               0 :      _state->sb_flags+fplane->sboffset,fplane->froffset,
     513                 :      fplane->nhfrags,fplane->nvfrags);
     514                 :   }
     515                 :   /*Create the mapping from macro blocks to fragments.*/
     516               0 :   oc_mb_create_mapping(_state->mb_maps,_state->mb_modes,
     517               0 :    _state->fplanes,_state->info.pixel_fmt);
     518                 :   /*Initialize the invalid and borderi fields of each fragment.*/
     519               0 :   oc_state_border_init(_state);
     520               0 :   return 0;
     521                 : }
     522                 : 
     523               0 : static void oc_state_frarray_clear(oc_theora_state *_state){
     524               0 :   _ogg_free(_state->coded_fragis);
     525               0 :   _ogg_free(_state->mb_modes);
     526               0 :   _ogg_free(_state->mb_maps);
     527               0 :   _ogg_free(_state->sb_flags);
     528               0 :   _ogg_free(_state->sb_maps);
     529               0 :   _ogg_free(_state->frag_mvs);
     530               0 :   _ogg_free(_state->frags);
     531               0 : }
     532                 : 
     533                 : 
     534                 : /*Initializes the buffers used for reconstructed frames.
     535                 :   These buffers are padded with 16 extra pixels on each side, to allow
     536                 :    unrestricted motion vectors without special casing the boundary.
     537                 :   If chroma is decimated in either direction, the padding is reduced by a
     538                 :    factor of 2 on the appropriate sides.
     539                 :   _nrefs: The number of reference buffers to init; must be in the range 3...6.*/
     540               0 : static int oc_state_ref_bufs_init(oc_theora_state *_state,int _nrefs){
     541                 :   th_info       *info;
     542                 :   unsigned char *ref_frame_data;
     543                 :   size_t         ref_frame_data_sz;
     544                 :   size_t         ref_frame_sz;
     545                 :   size_t         yplane_sz;
     546                 :   size_t         cplane_sz;
     547                 :   int            yhstride;
     548                 :   int            yheight;
     549                 :   int            chstride;
     550                 :   int            cheight;
     551                 :   ptrdiff_t      align;
     552                 :   ptrdiff_t      yoffset;
     553                 :   ptrdiff_t      coffset;
     554                 :   ptrdiff_t     *frag_buf_offs;
     555                 :   ptrdiff_t      fragi;
     556                 :   int            hdec;
     557                 :   int            vdec;
     558                 :   int            rfi;
     559                 :   int            pli;
     560               0 :   if(_nrefs<3||_nrefs>6)return TH_EINVAL;
     561               0 :   info=&_state->info;
     562                 :   /*Compute the image buffer parameters for each plane.*/
     563               0 :   hdec=!(info->pixel_fmt&1);
     564               0 :   vdec=!(info->pixel_fmt&2);
     565               0 :   yhstride=info->frame_width+2*OC_UMV_PADDING;
     566               0 :   yheight=info->frame_height+2*OC_UMV_PADDING;
     567                 :   /*Require 16-byte aligned rows in the chroma planes.*/
     568               0 :   chstride=(yhstride>>hdec)+15&~15;
     569               0 :   cheight=yheight>>vdec;
     570               0 :   yplane_sz=yhstride*(size_t)yheight;
     571               0 :   cplane_sz=chstride*(size_t)cheight;
     572               0 :   yoffset=OC_UMV_PADDING+OC_UMV_PADDING*(ptrdiff_t)yhstride;
     573               0 :   coffset=(OC_UMV_PADDING>>hdec)+(OC_UMV_PADDING>>vdec)*(ptrdiff_t)chstride;
     574                 :   /*Although we guarantee the rows of the chroma planes are a multiple of 16
     575                 :      bytes, the initial padding on the first row may only be 8 bytes.
     576                 :     Compute the offset needed to the actual image data to a multiple of 16.*/
     577               0 :   align=-coffset&15;
     578               0 :   ref_frame_sz=yplane_sz+2*cplane_sz+16;
     579               0 :   ref_frame_data_sz=_nrefs*ref_frame_sz;
     580                 :   /*Check for overflow.
     581                 :     The same caveats apply as for oc_state_frarray_init().*/
     582               0 :   if(yplane_sz/yhstride!=(size_t)yheight||2*cplane_sz+16<cplane_sz||
     583               0 :    ref_frame_sz<yplane_sz||ref_frame_data_sz/_nrefs!=ref_frame_sz){
     584               0 :     return TH_EIMPL;
     585                 :   }
     586               0 :   ref_frame_data=oc_aligned_malloc(ref_frame_data_sz,16);
     587               0 :   frag_buf_offs=_state->frag_buf_offs=
     588               0 :    _ogg_malloc(_state->nfrags*sizeof(*frag_buf_offs));
     589               0 :   if(ref_frame_data==NULL||frag_buf_offs==NULL){
     590               0 :     _ogg_free(frag_buf_offs);
     591               0 :     oc_aligned_free(ref_frame_data);
     592               0 :     return TH_EFAULT;
     593                 :   }
     594                 :   /*Set up the width, height and stride for the image buffers.*/
     595               0 :   _state->ref_frame_bufs[0][0].width=info->frame_width;
     596               0 :   _state->ref_frame_bufs[0][0].height=info->frame_height;
     597               0 :   _state->ref_frame_bufs[0][0].stride=yhstride;
     598               0 :   _state->ref_frame_bufs[0][1].width=_state->ref_frame_bufs[0][2].width=
     599               0 :    info->frame_width>>hdec;
     600               0 :   _state->ref_frame_bufs[0][1].height=_state->ref_frame_bufs[0][2].height=
     601               0 :    info->frame_height>>vdec;
     602               0 :   _state->ref_frame_bufs[0][1].stride=_state->ref_frame_bufs[0][2].stride=
     603                 :    chstride;
     604               0 :   for(rfi=1;rfi<_nrefs;rfi++){
     605               0 :     memcpy(_state->ref_frame_bufs[rfi],_state->ref_frame_bufs[0],
     606                 :      sizeof(_state->ref_frame_bufs[0]));
     607                 :   }
     608               0 :   _state->ref_frame_handle=ref_frame_data;
     609                 :   /*Set up the data pointers for the image buffers.*/
     610               0 :   for(rfi=0;rfi<_nrefs;rfi++){
     611               0 :     _state->ref_frame_bufs[rfi][0].data=ref_frame_data+yoffset;
     612               0 :     ref_frame_data+=yplane_sz+align;
     613               0 :     _state->ref_frame_bufs[rfi][1].data=ref_frame_data+coffset;
     614               0 :     ref_frame_data+=cplane_sz;
     615               0 :     _state->ref_frame_bufs[rfi][2].data=ref_frame_data+coffset;
     616               0 :     ref_frame_data+=cplane_sz+(16-align);
     617                 :     /*Flip the buffer upside down.
     618                 :       This allows us to decode Theora's bottom-up frames in their natural
     619                 :        order, yet return a top-down buffer with a positive stride to the user.*/
     620               0 :     oc_ycbcr_buffer_flip(_state->ref_frame_bufs[rfi],
     621               0 :      _state->ref_frame_bufs[rfi]);
     622                 :   }
     623               0 :   _state->ref_ystride[0]=-yhstride;
     624               0 :   _state->ref_ystride[1]=_state->ref_ystride[2]=-chstride;
     625                 :   /*Initialize the fragment buffer offsets.*/
     626               0 :   ref_frame_data=_state->ref_frame_bufs[0][0].data;
     627               0 :   fragi=0;
     628               0 :   for(pli=0;pli<3;pli++){
     629                 :     th_img_plane      *iplane;
     630                 :     oc_fragment_plane *fplane;
     631                 :     unsigned char     *vpix;
     632                 :     ptrdiff_t          stride;
     633                 :     ptrdiff_t          vfragi_end;
     634                 :     int                nhfrags;
     635               0 :     iplane=_state->ref_frame_bufs[0]+pli;
     636               0 :     fplane=_state->fplanes+pli;
     637               0 :     vpix=iplane->data;
     638               0 :     vfragi_end=fplane->froffset+fplane->nfrags;
     639               0 :     nhfrags=fplane->nhfrags;
     640               0 :     stride=iplane->stride;
     641               0 :     while(fragi<vfragi_end){
     642                 :       ptrdiff_t      hfragi_end;
     643                 :       unsigned char *hpix;
     644               0 :       hpix=vpix;
     645               0 :       for(hfragi_end=fragi+nhfrags;fragi<hfragi_end;fragi++){
     646               0 :         frag_buf_offs[fragi]=hpix-ref_frame_data;
     647               0 :         hpix+=8;
     648                 :       }
     649               0 :       vpix+=stride<<3;
     650                 :     }
     651                 :   }
     652                 :   /*Initialize the reference frame pointers and indices.*/
     653               0 :   _state->ref_frame_idx[OC_FRAME_GOLD]=
     654               0 :    _state->ref_frame_idx[OC_FRAME_PREV]=
     655               0 :    _state->ref_frame_idx[OC_FRAME_GOLD_ORIG]=
     656               0 :    _state->ref_frame_idx[OC_FRAME_PREV_ORIG]=
     657               0 :    _state->ref_frame_idx[OC_FRAME_SELF]=
     658               0 :    _state->ref_frame_idx[OC_FRAME_IO]=-1;
     659               0 :   _state->ref_frame_data[OC_FRAME_GOLD]=
     660               0 :    _state->ref_frame_data[OC_FRAME_PREV]=
     661               0 :    _state->ref_frame_data[OC_FRAME_GOLD_ORIG]=
     662               0 :    _state->ref_frame_data[OC_FRAME_PREV_ORIG]=
     663               0 :    _state->ref_frame_data[OC_FRAME_SELF]=
     664               0 :    _state->ref_frame_data[OC_FRAME_IO]=NULL;
     665               0 :   return 0;
     666                 : }
     667                 : 
     668               0 : static void oc_state_ref_bufs_clear(oc_theora_state *_state){
     669               0 :   _ogg_free(_state->frag_buf_offs);
     670               0 :   oc_aligned_free(_state->ref_frame_handle);
     671               0 : }
     672                 : 
     673                 : 
     674               0 : void oc_state_accel_init_c(oc_theora_state *_state){
     675               0 :   _state->cpu_flags=0;
     676                 : #if defined(OC_STATE_USE_VTABLE)
     677               0 :   _state->opt_vtable.frag_copy=oc_frag_copy_c;
     678               0 :   _state->opt_vtable.frag_copy_list=oc_frag_copy_list_c;
     679               0 :   _state->opt_vtable.frag_recon_intra=oc_frag_recon_intra_c;
     680               0 :   _state->opt_vtable.frag_recon_inter=oc_frag_recon_inter_c;
     681               0 :   _state->opt_vtable.frag_recon_inter2=oc_frag_recon_inter2_c;
     682               0 :   _state->opt_vtable.idct8x8=oc_idct8x8_c;
     683               0 :   _state->opt_vtable.state_frag_recon=oc_state_frag_recon_c;
     684               0 :   _state->opt_vtable.loop_filter_init=oc_loop_filter_init_c;
     685               0 :   _state->opt_vtable.state_loop_filter_frag_rows=
     686                 :    oc_state_loop_filter_frag_rows_c;
     687               0 :   _state->opt_vtable.restore_fpu=oc_restore_fpu_c;
     688                 : #endif
     689               0 :   _state->opt_data.dct_fzig_zag=OC_FZIG_ZAG;
     690               0 : }
     691                 : 
     692                 : 
     693               0 : int oc_state_init(oc_theora_state *_state,const th_info *_info,int _nrefs){
     694                 :   int ret;
     695                 :   /*First validate the parameters.*/
     696               0 :   if(_info==NULL)return TH_EFAULT;
     697                 :   /*The width and height of the encoded frame must be multiples of 16.
     698                 :     They must also, when divided by 16, fit into a 16-bit unsigned integer.
     699                 :     The displayable frame offset coordinates must fit into an 8-bit unsigned
     700                 :      integer.
     701                 :     Note that the offset Y in the API is specified on the opposite side from
     702                 :      how it is specified in the bitstream, because the Y axis is flipped in
     703                 :      the bitstream.
     704                 :     The displayable frame must fit inside the encoded frame.
     705                 :     The color space must be one known by the encoder.*/
     706               0 :   if((_info->frame_width&0xF)||(_info->frame_height&0xF)||
     707               0 :    _info->frame_width<=0||_info->frame_width>=0x100000||
     708               0 :    _info->frame_height<=0||_info->frame_height>=0x100000||
     709               0 :    _info->pic_x+_info->pic_width>_info->frame_width||
     710               0 :    _info->pic_y+_info->pic_height>_info->frame_height||
     711               0 :    _info->pic_x>255||_info->frame_height-_info->pic_height-_info->pic_y>255||
     712                 :    /*Note: the following <0 comparisons may generate spurious warnings on
     713                 :       platforms where enums are unsigned.
     714                 :      We could cast them to unsigned and just use the following >= comparison,
     715                 :       but there are a number of compilers which will mis-optimize this.
     716                 :      It's better to live with the spurious warnings.*/
     717               0 :    _info->colorspace<0||_info->colorspace>=TH_CS_NSPACES||
     718               0 :    _info->pixel_fmt<0||_info->pixel_fmt>=TH_PF_NFORMATS){
     719               0 :     return TH_EINVAL;
     720                 :   }
     721               0 :   memset(_state,0,sizeof(*_state));
     722               0 :   memcpy(&_state->info,_info,sizeof(*_info));
     723                 :   /*Invert the sense of pic_y to match Theora's right-handed coordinate
     724                 :      system.*/
     725               0 :   _state->info.pic_y=_info->frame_height-_info->pic_height-_info->pic_y;
     726               0 :   _state->frame_type=OC_UNKWN_FRAME;
     727               0 :   oc_state_accel_init(_state);
     728               0 :   ret=oc_state_frarray_init(_state);
     729               0 :   if(ret>=0)ret=oc_state_ref_bufs_init(_state,_nrefs);
     730               0 :   if(ret<0){
     731               0 :     oc_state_frarray_clear(_state);
     732               0 :     return ret;
     733                 :   }
     734                 :   /*If the keyframe_granule_shift is out of range, use the maximum allowable
     735                 :      value.*/
     736               0 :   if(_info->keyframe_granule_shift<0||_info->keyframe_granule_shift>31){
     737               0 :     _state->info.keyframe_granule_shift=31;
     738                 :   }
     739               0 :   _state->keyframe_num=0;
     740               0 :   _state->curframe_num=-1;
     741                 :   /*3.2.0 streams mark the frame index instead of the frame count.
     742                 :     This was changed with stream version 3.2.1 to conform to other Ogg
     743                 :      codecs.
     744                 :     We add an extra bias when computing granule positions for new streams.*/
     745               0 :   _state->granpos_bias=TH_VERSION_CHECK(_info,3,2,1);
     746               0 :   return 0;
     747                 : }
     748                 : 
     749               0 : void oc_state_clear(oc_theora_state *_state){
     750               0 :   oc_state_ref_bufs_clear(_state);
     751               0 :   oc_state_frarray_clear(_state);
     752               0 : }
     753                 : 
     754                 : 
     755                 : /*Duplicates the pixels on the border of the image plane out into the
     756                 :    surrounding padding for use by unrestricted motion vectors.
     757                 :   This function only adds the left and right borders, and only for the fragment
     758                 :    rows specified.
     759                 :   _refi: The index of the reference buffer to pad.
     760                 :   _pli:  The color plane.
     761                 :   _y0:   The Y coordinate of the first row to pad.
     762                 :   _yend: The Y coordinate of the row to stop padding at.*/
     763               0 : void oc_state_borders_fill_rows(oc_theora_state *_state,int _refi,int _pli,
     764                 :  int _y0,int _yend){
     765                 :   th_img_plane  *iplane;
     766                 :   unsigned char *apix;
     767                 :   unsigned char *bpix;
     768                 :   unsigned char *epix;
     769                 :   int            stride;
     770                 :   int            hpadding;
     771               0 :   hpadding=OC_UMV_PADDING>>(_pli!=0&&!(_state->info.pixel_fmt&1));
     772               0 :   iplane=_state->ref_frame_bufs[_refi]+_pli;
     773               0 :   stride=iplane->stride;
     774               0 :   apix=iplane->data+_y0*(ptrdiff_t)stride;
     775               0 :   bpix=apix+iplane->width-1;
     776               0 :   epix=iplane->data+_yend*(ptrdiff_t)stride;
     777                 :   /*Note the use of != instead of <, which allows the stride to be negative.*/
     778               0 :   while(apix!=epix){
     779               0 :     memset(apix-hpadding,apix[0],hpadding);
     780               0 :     memset(bpix+1,bpix[0],hpadding);
     781               0 :     apix+=stride;
     782               0 :     bpix+=stride;
     783                 :   }
     784               0 : }
     785                 : 
     786                 : /*Duplicates the pixels on the border of the image plane out into the
     787                 :    surrounding padding for use by unrestricted motion vectors.
     788                 :   This function only adds the top and bottom borders, and must be called after
     789                 :    the left and right borders are added.
     790                 :   _refi:      The index of the reference buffer to pad.
     791                 :   _pli:       The color plane.*/
     792               0 : void oc_state_borders_fill_caps(oc_theora_state *_state,int _refi,int _pli){
     793                 :   th_img_plane  *iplane;
     794                 :   unsigned char *apix;
     795                 :   unsigned char *bpix;
     796                 :   unsigned char *epix;
     797                 :   int            stride;
     798                 :   int            hpadding;
     799                 :   int            vpadding;
     800                 :   int            fullw;
     801               0 :   hpadding=OC_UMV_PADDING>>(_pli!=0&&!(_state->info.pixel_fmt&1));
     802               0 :   vpadding=OC_UMV_PADDING>>(_pli!=0&&!(_state->info.pixel_fmt&2));
     803               0 :   iplane=_state->ref_frame_bufs[_refi]+_pli;
     804               0 :   stride=iplane->stride;
     805               0 :   fullw=iplane->width+(hpadding<<1);
     806               0 :   apix=iplane->data-hpadding;
     807               0 :   bpix=iplane->data+(iplane->height-1)*(ptrdiff_t)stride-hpadding;
     808               0 :   epix=apix-stride*(ptrdiff_t)vpadding;
     809               0 :   while(apix!=epix){
     810               0 :     memcpy(apix-stride,apix,fullw);
     811               0 :     memcpy(bpix+stride,bpix,fullw);
     812               0 :     apix-=stride;
     813               0 :     bpix+=stride;
     814                 :   }
     815               0 : }
     816                 : 
     817                 : /*Duplicates the pixels on the border of the given reference image out into
     818                 :    the surrounding padding for use by unrestricted motion vectors.
     819                 :   _state: The context containing the reference buffers.
     820                 :   _refi:  The index of the reference buffer to pad.*/
     821               0 : void oc_state_borders_fill(oc_theora_state *_state,int _refi){
     822                 :   int pli;
     823               0 :   for(pli=0;pli<3;pli++){
     824               0 :     oc_state_borders_fill_rows(_state,_refi,pli,0,
     825                 :      _state->ref_frame_bufs[_refi][pli].height);
     826               0 :     oc_state_borders_fill_caps(_state,_refi,pli);
     827                 :   }
     828               0 : }
     829                 : 
     830                 : /*Determines the offsets in an image buffer to use for motion compensation.
     831                 :   _state:   The Theora state the offsets are to be computed with.
     832                 :   _offsets: Returns the offset for the buffer(s).
     833                 :             _offsets[0] is always set.
     834                 :             _offsets[1] is set if the motion vector has non-zero fractional
     835                 :              components.
     836                 :   _pli:     The color plane index.
     837                 :   _mv:      The motion vector.
     838                 :   Return: The number of offsets returned: 1 or 2.*/
     839               0 : int oc_state_get_mv_offsets(const oc_theora_state *_state,int _offsets[2],
     840                 :  int _pli,oc_mv _mv){
     841                 :   /*Here is a brief description of how Theora handles motion vectors:
     842                 :     Motion vector components are specified to half-pixel accuracy in
     843                 :      undecimated directions of each plane, and quarter-pixel accuracy in
     844                 :      decimated directions.
     845                 :     Integer parts are extracted by dividing (not shifting) by the
     846                 :      appropriate amount, with truncation towards zero.
     847                 :     These integer values are used to calculate the first offset.
     848                 : 
     849                 :     If either of the fractional parts are non-zero, then a second offset is
     850                 :      computed.
     851                 :     No third or fourth offsets are computed, even if both components have
     852                 :      non-zero fractional parts.
     853                 :     The second offset is computed by dividing (not shifting) by the
     854                 :      appropriate amount, always truncating _away_ from zero.*/
     855                 : #if 0
     856                 :   /*This version of the code doesn't use any tables, but is slower.*/
     857                 :   int ystride;
     858                 :   int xprec;
     859                 :   int yprec;
     860                 :   int xfrac;
     861                 :   int yfrac;
     862                 :   int offs;
     863                 :   int dx;
     864                 :   int dy;
     865                 :   ystride=_state->ref_ystride[_pli];
     866                 :   /*These two variables decide whether we are in half- or quarter-pixel
     867                 :      precision in each component.*/
     868                 :   xprec=1+(_pli!=0&&!(_state->info.pixel_fmt&1));
     869                 :   yprec=1+(_pli!=0&&!(_state->info.pixel_fmt&2));
     870                 :   dx=OC_MV_X(_mv);
     871                 :   dy=OC_MV_Y(_mv);
     872                 :   /*These two variables are either 0 if all the fractional bits are zero or -1
     873                 :      if any of them are non-zero.*/
     874                 :   xfrac=OC_SIGNMASK(-(dx&(xprec|1)));
     875                 :   yfrac=OC_SIGNMASK(-(dy&(yprec|1)));
     876                 :   offs=(dx>>xprec)+(dy>>yprec)*ystride;
     877                 :   if(xfrac||yfrac){
     878                 :     int xmask;
     879                 :     int ymask;
     880                 :     xmask=OC_SIGNMASK(dx);
     881                 :     ymask=OC_SIGNMASK(dy);
     882                 :     yfrac&=ystride;
     883                 :     _offsets[0]=offs-(xfrac&xmask)+(yfrac&ymask);
     884                 :     _offsets[1]=offs-(xfrac&~xmask)+(yfrac&~ymask);
     885                 :     return 2;
     886                 :   }
     887                 :   else{
     888                 :     _offsets[0]=offs;
     889                 :     return 1;
     890                 :   }
     891                 : #else
     892                 :   /*Using tables simplifies the code, and there's enough arithmetic to hide the
     893                 :      latencies of the memory references.*/
     894                 :   static const signed char OC_MVMAP[2][64]={
     895                 :     {
     896                 :           -15,-15,-14,-14,-13,-13,-12,-12,-11,-11,-10,-10, -9, -9, -8,
     897                 :        -8, -7, -7, -6, -6, -5, -5, -4, -4, -3, -3, -2, -2, -1, -1,  0,
     898                 :         0,  0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  6,  7,  7,
     899                 :         8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15
     900                 :     },
     901                 :     {
     902                 :            -7, -7, -7, -7, -6, -6, -6, -6, -5, -5, -5, -5, -4, -4, -4,
     903                 :        -4, -3, -3, -3, -3, -2, -2, -2, -2, -1, -1, -1, -1,  0,  0,  0,
     904                 :         0,  0,  0,  0,  1,  1,  1,  1,  2,  2,  2,  2,  3,  3,  3,  3,
     905                 :         4,  4,  4,  4,  5,  5,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7
     906                 :     }
     907                 :   };
     908                 :   static const signed char OC_MVMAP2[2][64]={
     909                 :     {
     910                 :         -1, 0,-1,  0,-1, 0,-1,  0,-1, 0,-1,  0,-1, 0,-1,
     911                 :       0,-1, 0,-1,  0,-1, 0,-1,  0,-1, 0,-1,  0,-1, 0,-1,
     912                 :       0, 1, 0, 1,  0, 1, 0, 1,  0, 1, 0, 1,  0, 1, 0, 1,
     913                 :       0, 1, 0, 1,  0, 1, 0, 1,  0, 1, 0, 1,  0, 1, 0, 1
     914                 :     },
     915                 :     {
     916                 :         -1,-1,-1,  0,-1,-1,-1,  0,-1,-1,-1,  0,-1,-1,-1,
     917                 :       0,-1,-1,-1,  0,-1,-1,-1,  0,-1,-1,-1,  0,-1,-1,-1,
     918                 :       0, 1, 1, 1,  0, 1, 1, 1,  0, 1, 1, 1,  0, 1, 1, 1,
     919                 :       0, 1, 1, 1,  0, 1, 1, 1,  0, 1, 1, 1,  0, 1, 1, 1
     920                 :     }
     921                 :   };
     922                 :   int ystride;
     923                 :   int qpx;
     924                 :   int qpy;
     925                 :   int mx;
     926                 :   int my;
     927                 :   int mx2;
     928                 :   int my2;
     929                 :   int offs;
     930                 :   int dx;
     931                 :   int dy;
     932               0 :   ystride=_state->ref_ystride[_pli];
     933               0 :   qpy=_pli!=0&&!(_state->info.pixel_fmt&2);
     934               0 :   dx=OC_MV_X(_mv);
     935               0 :   dy=OC_MV_Y(_mv);
     936               0 :   my=OC_MVMAP[qpy][dy+31];
     937               0 :   my2=OC_MVMAP2[qpy][dy+31];
     938               0 :   qpx=_pli!=0&&!(_state->info.pixel_fmt&1);
     939               0 :   mx=OC_MVMAP[qpx][dx+31];
     940               0 :   mx2=OC_MVMAP2[qpx][dx+31];
     941               0 :   offs=my*ystride+mx;
     942               0 :   if(mx2||my2){
     943               0 :     _offsets[1]=offs+my2*ystride+mx2;
     944               0 :     _offsets[0]=offs;
     945               0 :     return 2;
     946                 :   }
     947               0 :   _offsets[0]=offs;
     948               0 :   return 1;
     949                 : #endif
     950                 : }
     951                 : 
     952               0 : void oc_state_frag_recon_c(const oc_theora_state *_state,ptrdiff_t _fragi,
     953                 :  int _pli,ogg_int16_t _dct_coeffs[128],int _last_zzi,ogg_uint16_t _dc_quant){
     954                 :   unsigned char *dst;
     955                 :   ptrdiff_t      frag_buf_off;
     956                 :   int            ystride;
     957                 :   int            refi;
     958                 :   /*Apply the inverse transform.*/
     959                 :   /*Special case only having a DC component.*/
     960               0 :   if(_last_zzi<2){
     961                 :     ogg_int16_t p;
     962                 :     int         ci;
     963                 :     /*We round this dequant product (and not any of the others) because there's
     964                 :        no iDCT rounding.*/
     965               0 :     p=(ogg_int16_t)(_dct_coeffs[0]*(ogg_int32_t)_dc_quant+15>>5);
     966                 :     /*LOOP VECTORIZES.*/
     967               0 :     for(ci=0;ci<64;ci++)_dct_coeffs[64+ci]=p;
     968                 :   }
     969                 :   else{
     970                 :     /*First, dequantize the DC coefficient.*/
     971               0 :     _dct_coeffs[0]=(ogg_int16_t)(_dct_coeffs[0]*(int)_dc_quant);
     972               0 :     oc_idct8x8(_state,_dct_coeffs+64,_dct_coeffs,_last_zzi);
     973                 :   }
     974                 :   /*Fill in the target buffer.*/
     975               0 :   frag_buf_off=_state->frag_buf_offs[_fragi];
     976               0 :   refi=_state->frags[_fragi].refi;
     977               0 :   ystride=_state->ref_ystride[_pli];
     978               0 :   dst=_state->ref_frame_data[OC_FRAME_SELF]+frag_buf_off;
     979               0 :   if(refi==OC_FRAME_SELF)oc_frag_recon_intra(_state,dst,ystride,_dct_coeffs+64);
     980                 :   else{
     981                 :     const unsigned char *ref;
     982                 :     int                  mvoffsets[2];
     983               0 :     ref=_state->ref_frame_data[refi]+frag_buf_off;
     984               0 :     if(oc_state_get_mv_offsets(_state,mvoffsets,_pli,
     985               0 :      _state->frag_mvs[_fragi])>1){
     986               0 :       oc_frag_recon_inter2(_state,
     987                 :        dst,ref+mvoffsets[0],ref+mvoffsets[1],ystride,_dct_coeffs+64);
     988                 :     }
     989                 :     else{
     990               0 :       oc_frag_recon_inter(_state,dst,ref+mvoffsets[0],ystride,_dct_coeffs+64);
     991                 :     }
     992                 :   }
     993               0 : }
     994                 : 
     995               0 : static void loop_filter_h(unsigned char *_pix,int _ystride,signed char *_bv){
     996                 :   int y;
     997               0 :   _pix-=2;
     998               0 :   for(y=0;y<8;y++){
     999                 :     int f;
    1000               0 :     f=_pix[0]-_pix[3]+3*(_pix[2]-_pix[1]);
    1001                 :     /*The _bv array is used to compute the function
    1002                 :       f=OC_CLAMPI(OC_MINI(-_2flimit-f,0),f,OC_MAXI(_2flimit-f,0));
    1003                 :       where _2flimit=_state->loop_filter_limits[_state->qis[0]]<<1;*/
    1004               0 :     f=*(_bv+(f+4>>3));
    1005               0 :     _pix[1]=OC_CLAMP255(_pix[1]+f);
    1006               0 :     _pix[2]=OC_CLAMP255(_pix[2]-f);
    1007               0 :     _pix+=_ystride;
    1008                 :   }
    1009               0 : }
    1010                 : 
    1011               0 : static void loop_filter_v(unsigned char *_pix,int _ystride,signed char *_bv){
    1012                 :   int x;
    1013               0 :   _pix-=_ystride*2;
    1014               0 :   for(x=0;x<8;x++){
    1015                 :     int f;
    1016               0 :     f=_pix[x]-_pix[_ystride*3+x]+3*(_pix[_ystride*2+x]-_pix[_ystride+x]);
    1017                 :     /*The _bv array is used to compute the function
    1018                 :       f=OC_CLAMPI(OC_MINI(-_2flimit-f,0),f,OC_MAXI(_2flimit-f,0));
    1019                 :       where _2flimit=_state->loop_filter_limits[_state->qis[0]]<<1;*/
    1020               0 :     f=*(_bv+(f+4>>3));
    1021               0 :     _pix[_ystride+x]=OC_CLAMP255(_pix[_ystride+x]+f);
    1022               0 :     _pix[_ystride*2+x]=OC_CLAMP255(_pix[_ystride*2+x]-f);
    1023                 :   }
    1024               0 : }
    1025                 : 
    1026                 : /*Initialize the bounding values array used by the loop filter.
    1027                 :   _bv: Storage for the array.
    1028                 :   _flimit: The filter limit as defined in Section 7.10 of the spec.*/
    1029               0 : void oc_loop_filter_init_c(signed char _bv[256],int _flimit){
    1030                 :   int i;
    1031               0 :   memset(_bv,0,sizeof(_bv[0])*256);
    1032               0 :   for(i=0;i<_flimit;i++){
    1033               0 :     if(127-i-_flimit>=0)_bv[127-i-_flimit]=(signed char)(i-_flimit);
    1034               0 :     _bv[127-i]=(signed char)(-i);
    1035               0 :     _bv[127+i]=(signed char)(i);
    1036               0 :     if(127+i+_flimit<256)_bv[127+i+_flimit]=(signed char)(_flimit-i);
    1037                 :   }
    1038               0 : }
    1039                 : 
    1040                 : /*Apply the loop filter to a given set of fragment rows in the given plane.
    1041                 :   The filter may be run on the bottom edge, affecting pixels in the next row of
    1042                 :    fragments, so this row also needs to be available.
    1043                 :   _bv:        The bounding values array.
    1044                 :   _refi:      The index of the frame buffer to filter.
    1045                 :   _pli:       The color plane to filter.
    1046                 :   _fragy0:    The Y coordinate of the first fragment row to filter.
    1047                 :   _fragy_end: The Y coordinate of the fragment row to stop filtering at.*/
    1048               0 : void oc_state_loop_filter_frag_rows_c(const oc_theora_state *_state,
    1049                 :  signed char *_bv,int _refi,int _pli,int _fragy0,int _fragy_end){
    1050                 :   const oc_fragment_plane *fplane;
    1051                 :   const oc_fragment       *frags;
    1052                 :   const ptrdiff_t         *frag_buf_offs;
    1053                 :   unsigned char           *ref_frame_data;
    1054                 :   ptrdiff_t                fragi_top;
    1055                 :   ptrdiff_t                fragi_bot;
    1056                 :   ptrdiff_t                fragi0;
    1057                 :   ptrdiff_t                fragi0_end;
    1058                 :   int                      ystride;
    1059                 :   int                      nhfrags;
    1060               0 :   _bv+=127;
    1061               0 :   fplane=_state->fplanes+_pli;
    1062               0 :   nhfrags=fplane->nhfrags;
    1063               0 :   fragi_top=fplane->froffset;
    1064               0 :   fragi_bot=fragi_top+fplane->nfrags;
    1065               0 :   fragi0=fragi_top+_fragy0*(ptrdiff_t)nhfrags;
    1066               0 :   fragi0_end=fragi_top+_fragy_end*(ptrdiff_t)nhfrags;
    1067               0 :   ystride=_state->ref_ystride[_pli];
    1068               0 :   frags=_state->frags;
    1069               0 :   frag_buf_offs=_state->frag_buf_offs;
    1070               0 :   ref_frame_data=_state->ref_frame_data[_refi];
    1071                 :   /*The following loops are constructed somewhat non-intuitively on purpose.
    1072                 :     The main idea is: if a block boundary has at least one coded fragment on
    1073                 :      it, the filter is applied to it.
    1074                 :     However, the order that the filters are applied in matters, and VP3 chose
    1075                 :      the somewhat strange ordering used below.*/
    1076               0 :   while(fragi0<fragi0_end){
    1077                 :     ptrdiff_t fragi;
    1078                 :     ptrdiff_t fragi_end;
    1079               0 :     fragi=fragi0;
    1080               0 :     fragi_end=fragi+nhfrags;
    1081               0 :     while(fragi<fragi_end){
    1082               0 :       if(frags[fragi].coded){
    1083                 :         unsigned char *ref;
    1084               0 :         ref=ref_frame_data+frag_buf_offs[fragi];
    1085               0 :         if(fragi>fragi0)loop_filter_h(ref,ystride,_bv);
    1086               0 :         if(fragi0>fragi_top)loop_filter_v(ref,ystride,_bv);
    1087               0 :         if(fragi+1<fragi_end&&!frags[fragi+1].coded){
    1088               0 :           loop_filter_h(ref+8,ystride,_bv);
    1089                 :         }
    1090               0 :         if(fragi+nhfrags<fragi_bot&&!frags[fragi+nhfrags].coded){
    1091               0 :           loop_filter_v(ref+(ystride<<3),ystride,_bv);
    1092                 :         }
    1093                 :       }
    1094               0 :       fragi++;
    1095                 :     }
    1096               0 :     fragi0+=nhfrags;
    1097                 :   }
    1098               0 : }
    1099                 : 
    1100                 : #if defined(OC_DUMP_IMAGES)
    1101                 : int oc_state_dump_frame(const oc_theora_state *_state,int _frame,
    1102                 :  const char *_suf){
    1103                 :   /*Dump a PNG of the reconstructed image.*/
    1104                 :   png_structp    png;
    1105                 :   png_infop      info;
    1106                 :   png_bytep     *image;
    1107                 :   FILE          *fp;
    1108                 :   char           fname[16];
    1109                 :   unsigned char *y_row;
    1110                 :   unsigned char *u_row;
    1111                 :   unsigned char *v_row;
    1112                 :   unsigned char *y;
    1113                 :   unsigned char *u;
    1114                 :   unsigned char *v;
    1115                 :   ogg_int64_t    iframe;
    1116                 :   ogg_int64_t    pframe;
    1117                 :   int            y_stride;
    1118                 :   int            u_stride;
    1119                 :   int            v_stride;
    1120                 :   int            framei;
    1121                 :   int            width;
    1122                 :   int            height;
    1123                 :   int            imgi;
    1124                 :   int            imgj;
    1125                 :   width=_state->info.frame_width;
    1126                 :   height=_state->info.frame_height;
    1127                 :   iframe=_state->granpos>>_state->info.keyframe_granule_shift;
    1128                 :   pframe=_state->granpos-(iframe<<_state->info.keyframe_granule_shift);
    1129                 :   sprintf(fname,"%08i%s.png",(int)(iframe+pframe),_suf);
    1130                 :   fp=fopen(fname,"wb");
    1131                 :   if(fp==NULL)return TH_EFAULT;
    1132                 :   image=(png_bytep *)oc_malloc_2d(height,6*width,sizeof(**image));
    1133                 :   if(image==NULL){
    1134                 :     fclose(fp);
    1135                 :     return TH_EFAULT;
    1136                 :   }
    1137                 :   png=png_create_write_struct(PNG_LIBPNG_VER_STRING,NULL,NULL,NULL);
    1138                 :   if(png==NULL){
    1139                 :     oc_free_2d(image);
    1140                 :     fclose(fp);
    1141                 :     return TH_EFAULT;
    1142                 :   }
    1143                 :   info=png_create_info_struct(png);
    1144                 :   if(info==NULL){
    1145                 :     png_destroy_write_struct(&png,NULL);
    1146                 :     oc_free_2d(image);
    1147                 :     fclose(fp);
    1148                 :     return TH_EFAULT;
    1149                 :   }
    1150                 :   if(setjmp(png_jmpbuf(png))){
    1151                 :     png_destroy_write_struct(&png,&info);
    1152                 :     oc_free_2d(image);
    1153                 :     fclose(fp);
    1154                 :     return TH_EFAULT;
    1155                 :   }
    1156                 :   framei=_state->ref_frame_idx[_frame];
    1157                 :   y_row=_state->ref_frame_bufs[framei][0].data;
    1158                 :   u_row=_state->ref_frame_bufs[framei][1].data;
    1159                 :   v_row=_state->ref_frame_bufs[framei][2].data;
    1160                 :   y_stride=_state->ref_frame_bufs[framei][0].stride;
    1161                 :   u_stride=_state->ref_frame_bufs[framei][1].stride;
    1162                 :   v_stride=_state->ref_frame_bufs[framei][2].stride;
    1163                 :   /*Chroma up-sampling is just done with a box filter.
    1164                 :     This is very likely what will actually be used in practice on a real
    1165                 :      display, and also removes one more layer to search in for the source of
    1166                 :      artifacts.
    1167                 :     As an added bonus, it's dead simple.*/
    1168                 :   for(imgi=height;imgi-->0;){
    1169                 :     int dc;
    1170                 :     y=y_row;
    1171                 :     u=u_row;
    1172                 :     v=v_row;
    1173                 :     for(imgj=0;imgj<6*width;){
    1174                 :       float    yval;
    1175                 :       float    uval;
    1176                 :       float    vval;
    1177                 :       unsigned rval;
    1178                 :       unsigned gval;
    1179                 :       unsigned bval;
    1180                 :       /*This is intentionally slow and very accurate.*/
    1181                 :       yval=(*y-16)*(1.0F/219);
    1182                 :       uval=(*u-128)*(2*(1-0.114F)/224);
    1183                 :       vval=(*v-128)*(2*(1-0.299F)/224);
    1184                 :       rval=OC_CLAMPI(0,(int)(65535*(yval+vval)+0.5F),65535);
    1185                 :       gval=OC_CLAMPI(0,(int)(65535*(
    1186                 :        yval-uval*(0.114F/0.587F)-vval*(0.299F/0.587F))+0.5F),65535);
    1187                 :       bval=OC_CLAMPI(0,(int)(65535*(yval+uval)+0.5F),65535);
    1188                 :       image[imgi][imgj++]=(unsigned char)(rval>>8);
    1189                 :       image[imgi][imgj++]=(unsigned char)(rval&0xFF);
    1190                 :       image[imgi][imgj++]=(unsigned char)(gval>>8);
    1191                 :       image[imgi][imgj++]=(unsigned char)(gval&0xFF);
    1192                 :       image[imgi][imgj++]=(unsigned char)(bval>>8);
    1193                 :       image[imgi][imgj++]=(unsigned char)(bval&0xFF);
    1194                 :       dc=(y-y_row&1)|(_state->info.pixel_fmt&1);
    1195                 :       y++;
    1196                 :       u+=dc;
    1197                 :       v+=dc;
    1198                 :     }
    1199                 :     dc=-((height-1-imgi&1)|_state->info.pixel_fmt>>1);
    1200                 :     y_row+=y_stride;
    1201                 :     u_row+=dc&u_stride;
    1202                 :     v_row+=dc&v_stride;
    1203                 :   }
    1204                 :   png_init_io(png,fp);
    1205                 :   png_set_compression_level(png,Z_BEST_COMPRESSION);
    1206                 :   png_set_IHDR(png,info,width,height,16,PNG_COLOR_TYPE_RGB,
    1207                 :    PNG_INTERLACE_NONE,PNG_COMPRESSION_TYPE_DEFAULT,PNG_FILTER_TYPE_DEFAULT);
    1208                 :   switch(_state->info.colorspace){
    1209                 :     case TH_CS_ITU_REC_470M:{
    1210                 :       png_set_gAMA(png,info,2.2);
    1211                 :       png_set_cHRM_fixed(png,info,31006,31616,
    1212                 :        67000,32000,21000,71000,14000,8000);
    1213                 :     }break;
    1214                 :     case TH_CS_ITU_REC_470BG:{
    1215                 :       png_set_gAMA(png,info,2.67);
    1216                 :       png_set_cHRM_fixed(png,info,31271,32902,
    1217                 :        64000,33000,29000,60000,15000,6000);
    1218                 :     }break;
    1219                 :     default:break;
    1220                 :   }
    1221                 :   png_set_pHYs(png,info,_state->info.aspect_numerator,
    1222                 :    _state->info.aspect_denominator,0);
    1223                 :   png_set_rows(png,info,image);
    1224                 :   png_write_png(png,info,PNG_TRANSFORM_IDENTITY,NULL);
    1225                 :   png_write_end(png,info);
    1226                 :   png_destroy_write_struct(&png,&info);
    1227                 :   oc_free_2d(image);
    1228                 :   fclose(fp);
    1229                 :   return 0;
    1230                 : }
    1231                 : #endif
    1232                 : 
    1233                 : 
    1234                 : 
    1235               0 : ogg_int64_t th_granule_frame(void *_encdec,ogg_int64_t _granpos){
    1236                 :   oc_theora_state *state;
    1237               0 :   state=(oc_theora_state *)_encdec;
    1238               0 :   if(_granpos>=0){
    1239                 :     ogg_int64_t iframe;
    1240                 :     ogg_int64_t pframe;
    1241               0 :     iframe=_granpos>>state->info.keyframe_granule_shift;
    1242               0 :     pframe=_granpos-(iframe<<state->info.keyframe_granule_shift);
    1243                 :     /*3.2.0 streams store the frame index in the granule position.
    1244                 :       3.2.1 and later store the frame count.
    1245                 :       We return the index, so adjust the value if we have a 3.2.1 or later
    1246                 :        stream.*/
    1247               0 :     return iframe+pframe-TH_VERSION_CHECK(&state->info,3,2,1);
    1248                 :   }
    1249               0 :   return -1;
    1250                 : }
    1251                 : 
    1252               0 : double th_granule_time(void *_encdec,ogg_int64_t _granpos){
    1253                 :   oc_theora_state *state;
    1254               0 :   state=(oc_theora_state *)_encdec;
    1255               0 :   if(_granpos>=0){
    1256               0 :     return (th_granule_frame(_encdec, _granpos)+1)*(
    1257               0 :      (double)state->info.fps_denominator/state->info.fps_numerator);
    1258                 :   }
    1259               0 :   return -1;
    1260                 : }

Generated by: LCOV version 1.7