home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2004 March / PCWELT_3_2004.ISO / pcwsoft / flaskmpeg_078_39_src.z.exe / flaskmpeg / Video / VideoWrapper.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2002-10-28  |  50.6 KB  |  1,792 lines
  1. /* 
  2.  *  VideoWrapper.cpp 
  3.  *
  4.  *    Copyright (C) Alberto Vigata - January 2000  ultraflask@yahoo.com
  5.  *                 
  6.  *
  7.  *  This file is part of FlasKMPEG, a free MPEG to MPEG/AVI converter
  8.  *    
  9.  *  FlasKMPEG is free software; you can redistribute it and/or modify
  10.  *  it under the terms of the GNU General Public License as published by
  11.  *  the Free Software Foundation; either version 2, or (at your option)
  12.  *  any later version.
  13.  *   
  14.  *  FlasKMPEG is distributed in the hope that it will be useful,
  15.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  *  GNU General Public License for more details.
  18.  *   
  19.  *  You should have received a copy of the GNU General Public License
  20.  *  along with GNU Make; see the file COPYING.  If not, write to
  21.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  22.  *
  23.  */
  24.  
  25.  
  26. #include "VideoWrapper.h"
  27. #include "..\Subpic\Subpic.h"
  28. #include "..\cpusupport.h"
  29. #include "..\flrandom.h"
  30. #include "debug.h"
  31.  
  32. extern "C"
  33. { 
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36. #include <ctype.h>
  37. #include <fcntl.h>
  38. #include <assert.h>
  39.  
  40. #define GLOBAL
  41. #include "config.h"
  42. #include "global.h"
  43. //#include "getbits.h"
  44. }
  45.  
  46.  
  47. #include "misc_tables.h"
  48.  
  49. //#define TRACK_FRAMEINFO
  50. #define ABS(x) ((x>0)? x:-x)
  51.  
  52. const i64 nJumpBackwards = 102400;
  53.  
  54. //Global variables for syncing with decoding thread
  55. VideoWrapper *myVideo;
  56. int             gopPOS;
  57. bool         closedGOP;
  58. bool         synced=false;
  59.  
  60.  
  61. // This function returns the position of the 
  62. // stream in offset bytes from the buffer
  63. // Defined in getbits.cpp
  64. extern          int Get_Buffer_Pos();
  65. extern          void Reset_Bits_Buffer();
  66. extern unsigned int Set_Buffer_State( ui8 *buffer, ui32 offset, ui32 buffersize );
  67. extern          void picture_data();
  68.  
  69. /* private prototypes */
  70. static int  video_sequence _ANSI_ARGS_((int *framenum));
  71. static int Decode_Bitstream _ANSI_ARGS_((void));
  72. static void Process_Options _ANSI_ARGS_((int argc, char *argv[]));
  73. static void InitClip();
  74. static void DeInitClip();
  75.  
  76. bool NextSequenceHeader(){
  77.  
  78.   ui32 nStartCode=Show_Bits(32);
  79.   while (nStartCode!=0x000001B3  && nStartCode!=0x000001B7)
  80.   { 
  81.     Flush_Buffer(8);
  82.     nStartCode = Show_Bits(32);
  83.   }
  84.   if(nStartCode!=0x000001B3)
  85.     return false;
  86.   else
  87.     return true;
  88. }
  89.  
  90.  
  91. VideoWrapper::VideoWrapper()
  92. {
  93.     time          = 0;
  94.     error         = 0;
  95.     pictureWidth  = 0;
  96.     pictureHeight = 0;
  97.     myVideo       = this;
  98.     stopDecoding  = false;
  99.   m_nLastDecodedPictureStart = 0;
  100.  
  101.  
  102.   m_bSequenceInitialized = false;
  103.   
  104.   
  105.   Idct          = NULL;
  106.   m_hModule     = NULL;
  107.  
  108. }
  109.  
  110. VideoWrapper::~VideoWrapper()
  111. {
  112.  
  113.     if(m_bSequenceInitialized)
  114.     {
  115.         
  116.         DeInitClip();
  117.         DeinitializeSequence();
  118.     }
  119.     if(m_hModule)
  120.         FreeLibrary( m_hModule );
  121. }
  122.  
  123. void VideoWrapper::LoadIdctModule( char *szTemp )
  124. {
  125.   FMpegIdct_PluginFunc iDctPlugFunc;
  126.   FMpegIdctInfo        iDctInfo;
  127.   fmGetPluginFuncPtr      getPluginFunc;
  128.  
  129.   long nSupportedExt = CPUGetSupportedExtensions();
  130.   long nSupportedExtIdct = 0;
  131.  
  132.   if( m_hModule = LoadLibrary( szTemp ) )
  133.   {
  134.     if( getPluginFunc = (fmGetPluginFuncPtr)GetProcAddress( m_hModule, "fmGetPluginFunc" ) )
  135.     {
  136.       getPluginFunc( &iDctPlugFunc );
  137.       if (iDctPlugFunc.GetIdct && iDctPlugFunc.GetIdctCount)
  138.       {
  139.         for( int i=0; i< iDctPlugFunc.GetIdctCount(); i++ )
  140.         {
  141.           iDctPlugFunc.GetIdct( i, &iDctInfo );
  142.           // Check that the CPU supports this iDCT
  143.           nSupportedExtIdct = 0;
  144.           // Adapt flags from CPU support to iDCT api conventions
  145.           nSupportedExtIdct |= nSupportedExt&CPU_SUPPORTS_MMX ? SUPPORTS_MMX : 0;
  146.           nSupportedExtIdct |= nSupportedExt&CPU_SUPPORTS_SSE ? SUPPORTS_SSE : 0;
  147.           nSupportedExtIdct |= nSupportedExt&CPU_SUPPORTS_SSE2 ? SUPPORTS_SSE2 : 0;
  148.           nSupportedExtIdct |= nSupportedExt&CPU_SUPPORTS_3DNOW ? SUPPORTS_3DNOW : 0;
  149.           nSupportedExtIdct |= nSupportedExt&CPU_SUPPORTS_3DNOW_EXT ? SUPPORTS_3DNOW_EXT : 0;
  150.           nSupportedExtIdct &= PROCESSOR_SUPPORT_MASK;
  151.  
  152.           // If all the CPU features are supported
  153.           if( (iDctInfo.dwFlags&PROCESSOR_SUPPORT_MASK) & nSupportedExtIdct)
  154.             m_vIdct.AddItem( &iDctInfo );
  155.           // If no special CPU features are required add it also
  156.           else if( !(iDctInfo.dwFlags&PROCESSOR_SUPPORT_MASK) )
  157.             m_vIdct.AddItem( &iDctInfo );
  158.         }
  159.       }
  160.     }
  161.   }
  162.  
  163. }
  164.  
  165.  
  166. bool VideoWrapper::IdctSpeedTest()
  167. {
  168.   FMpegIdctInfo        iDctInfo;
  169.   i64   nStartTime, nEndTime;
  170.   i64   nMinTime = MAXLONGLONG;
  171.   bool  bTimerError = false;
  172.   FlRandom *pRandGen = new FlRandom;
  173.  
  174.   CFrame frTestFrame(NULL);
  175.   // This will allocate a chunk of aligned memory 
  176.   // to 16bytes boundaries.
  177.   frTestFrame.Set( 8, 8*250, FRAME_RGB32 );
  178.   // Get the buffer
  179.   short *shortbuf = (short *)frTestFrame.GetBuffer();
  180.   // Randomize block
  181.   for(int k=0; k<(8*8*250); k++)
  182.     shortbuf[k] = (short)pRandGen->Random(0, 2048);
  183.   
  184.   for(int i=0; i<m_vIdct.GetCount(); i++)
  185.   {
  186.     iDctInfo = m_vIdct[i];
  187.  
  188.     void (* idct)(short *block) = iDctInfo.Idct;
  189.     
  190.     // Perform speed test
  191.     if(iDctInfo.InitIdct)
  192.       iDctInfo.InitIdct();
  193.  
  194.     short *block = shortbuf;
  195.     QueryPerformanceCounter( (LARGE_INTEGER *)&nStartTime );
  196.     for(int j=0; j<250; j++)
  197.     {
  198.       for(k=0; k<64;k++)
  199.         idct(block);
  200.       block+=64;
  201.     }
  202.     QueryPerformanceCounter( (LARGE_INTEGER *)&nEndTime );
  203.  
  204.     if(iDctInfo.DeInitIdct)
  205.       iDctInfo.DeInitIdct();    
  206.     
  207.     if(nEndTime==0)
  208.     {
  209.       bTimerError = true;
  210.       break;
  211.     }
  212.  
  213.  
  214.     i64 nTestTime = nEndTime - nStartTime;
  215.     if( nTestTime < nMinTime )
  216.     {
  217.       nMinTime = nTestTime;
  218.       SelectIdct(i);
  219.     }
  220.  
  221.   }
  222.   // If we couldnt use QueryPerformanceCounter
  223.   if(bTimerError)
  224.   {
  225.     // Look for one that supports MMX
  226.     for(int i=0; i<m_vIdct.GetCount(); i++)
  227.     {
  228.       iDctInfo = m_vIdct[i];
  229.       if(iDctInfo.dwFlags&SUPPORTS_MMX)
  230.       {
  231.         SelectIdct(i);
  232.         break;
  233.       }
  234.     }
  235.     if( i>=m_vIdct.GetCount() )
  236.       SelectIdct(0);
  237.   }
  238.   return true;
  239. }
  240.  
  241. bool VideoWrapper::LoadIDCTs()
  242. {
  243.   WIN32_FIND_DATA find_data;
  244.   char     directory[MAX_PATH], szTemp[MAX_PATH];
  245.   
  246.   HANDLE   search_handle;
  247.   int      i;
  248.   
  249.   
  250.   sprintf(directory, "%s\\*.idct.flask", program_directory );
  251.   
  252.   m_vIdct.EmptyArray();
  253.   
  254.   i=0;
  255.   search_handle = FindFirstFile(directory, &find_data);
  256.   if(search_handle==INVALID_HANDLE_VALUE){
  257.     m_vIdct.EmptyArray();
  258.   }
  259.   else{
  260.     sprintf(szTemp,"%s\\%s", program_directory, find_data.cFileName );
  261.     LoadIdctModule( szTemp );
  262.     
  263.     while( FindNextFile(search_handle, &find_data ) ){
  264.       sprintf(szTemp,"%s\\%s", program_directory, find_data.cFileName );
  265.       LoadIdctModule( szTemp );
  266.     }
  267.     FindClose(search_handle);
  268.   }
  269.   
  270.   IdctSpeedTest();
  271.  
  272.   return m_vIdct.GetCount() > 0;
  273. }
  274.  
  275. int VideoWrapper::Init(TVideoInit *pInitParams)
  276. {
  277.     int ret;
  278.  
  279.   strcpy( this->program_directory, pInitParams->ProgramDirectory );
  280.   // Try to load iDCTs from files
  281.   if(!LoadIDCTs())
  282.     return 0;
  283.   // testing
  284.  
  285.     VideoWrapper::streamID    = pInitParams->nStreamId;
  286.     VideoWrapper::subStreamID = pInitParams->nSubStreamId;
  287.  
  288.     VideoWrapper::subpic_streamID    = pInitParams->nSubpicStreamId;
  289.     VideoWrapper::subpic_substreamID = pInitParams->nSubpicSubstreamId;
  290.  
  291.  
  292.  
  293.     
  294.     //Start demuxer
  295.     if(!SetInput(pInitParams->pMismInfo))
  296.         return 0;
  297.  
  298.     InitClip();               /* Creating clipping vector */
  299.  
  300.   //MSSG decoder Initialization
  301.   ld               = &base; /* select base context */
  302.   Frame_Store_Flag = 1;     /* store full frames */
  303.   Output_Type=2;            /* YUV format output */
  304.   System_Stream_Flag = 0;
  305.   
  306.   FlushBuffer();
  307.  
  308.     m_pTempVideoBuffer     = NULL;
  309.  
  310.     //GET  SEQUENCE PROPERTIES
  311.     CDemux::SetStreamPos(0);
  312.     StartReadLPES();
  313.     Initialize_Buffer(); 
  314.   if(!NextSequenceHeader())
  315.     return 0;
  316.   
  317.     /* Headers returns when end of sequence (0) or picture
  318.        header has been parsed (1) */
  319.     ret = Get_Hdr();
  320.     if(ret==1)
  321.     {
  322.        //VIDEO SEQUENCE....
  323.       Sequence_Framenum=0;
  324.         InitializeSequence();
  325.         pictureWidth = Coded_Picture_Width;
  326.         pictureHeight= Coded_Picture_Height;
  327.  
  328.     m_bSequenceInitialized = true;
  329.     }
  330.   else
  331.     return 0;
  332.  
  333.   // Now, guess if this is 24fps 
  334.   detectedFrameRateCode = Is24Progressive() ? 1 : frame_rate_code;
  335.   updateVideoStats();
  336.  
  337.  
  338.     // Rewind stream
  339.     CDemux::SetStreamPos(0);
  340.     StartReadLPES();
  341.     Initialize_Buffer(); 
  342.     synced=true;
  343.   
  344.   // Store clut
  345.   pClut = pInitParams->clut;
  346.  
  347.     return 1;
  348. }
  349.  
  350. void VideoWrapper::FlushBuffer()
  351. {
  352.   m_pTempVideoBuffer     = NULL;
  353.   m_nTempVideoBufferPtr  = 0;
  354.   m_nTempVideoBufferSize = 0;
  355.   m_nPesPosState         = PesNotDefined;
  356.   Reset_Bits_Buffer();
  357. }
  358.  
  359. int VideoWrapper::Start(TVideoOptions *opt)
  360. {
  361.   
  362.  
  363.    m_bFronFrameIsReady = false;
  364.    m_pFrontFrame = m_pBackFrame = NULL;
  365.    m_pFrameBuffer = opt->pFrameBuffer;
  366. /*
  367.    // Output temporary YUV frame for adaptation to output
  368.    switch( m_nOutFormat )
  369.    {
  370.      case FRAME_RGB32:
  371.        m_oYuvFrame.Set( pictureWidth,  pictureHeight, FRAME_YUV444  );
  372.        m_oUtilFrame.Set( pictureWidth, pictureHeight, FRAME_RGB32 );
  373.        m_oYuvFrame.SetBuffer( (ui8*)&sYuvFrame );       
  374.        break;
  375.      case FRAME_YV12:
  376.        m_oYuvFrame.Set( pictureWidth,  pictureHeight, FRAME_YUV420 );
  377.        m_oUtilFrame.Set( pictureWidth, pictureHeight, FRAME_YV12 );
  378.        m_oYuvFrame.SetBuffer( (ui8*)&sYuvFrame );       
  379.        break;
  380.    }*/
  381.  
  382.  
  383.    m_bSyncedNotEnoughReferences = false;
  384.    m_bFirstPictureDecoded   = false;
  385.    m_bPreviousDirWasForward = false;
  386.  
  387.     time=0;
  388.     SelectIdct( opt->idctIndex ); 
  389.   /* IDCT */
  390.   if( myVideo->InitIdct )
  391.     myVideo->InitIdct();
  392.  
  393.     m_bTopFieldExpected = true;
  394.  
  395.     //Decoder Configuration
  396.     timeCode.frame=0;
  397.     timeCode.hour=0;
  398.     timeCode.minute=0;
  399.     timeCode.second=0;
  400.     stopDecoding=false;
  401.  
  402.   // Only allow recons_progressive flag if the frame rate is 29.97 or 30
  403.   if( frame_rate_code == 4 || frame_rate_code == 5 )
  404.     recons_progressive     = opt->recons_progressive;
  405.   else
  406.     recons_progressive = false;
  407.   
  408.   memset(&p, 0, sizeof(presTimes));
  409.     internalPTS=0;
  410.  
  411.     // Pull down stuff
  412.     pullDownDetected=false;
  413.     pulldown_state  = 3;
  414.     interlaced_field_delay = (__int64)(MPEG2_CLK_REF*(frameDelay))>>1;
  415.   progressive_frame_delay = (__int64)(MPEG2_CLK_REF*(1.25*frameDelay));
  416.  
  417.     Bitstream_Framenum = 0;
  418.     sequencePos=SEQ_FIRSTTIME;
  419.  
  420.  
  421.  
  422.   if( opt->bStartInSync )
  423.   {
  424.  
  425.     // During this start-stop sequence, only calls to GetFrame, can be performed
  426.     // Timestamps will be valid since the sync point.
  427.     // In the start part, we retrieve any possible references needed for the decoding
  428.     // of the first frame.
  429.     // We first set our position to the sync position
  430.     CDemux::SetStreamPos( opt->nSyncPoint );
  431.     // Flush the buffer
  432.     FlushBuffer();
  433.     // Now we decode the previous picture.
  434.     // This will retrieve any references needed.
  435.     // If there are not enough references available, inform about it
  436.     // (likely we're at the beginning of the file)
  437.     // First align the stream with the first picture to be decoded.
  438.     int nParams = SEARCH_P | SEARCH_I | SEARCH_B | SEARCH_FORWARD  | SEARCH_ALIGN_FIRST_FIELD;
  439.     // This shoudlnt fail
  440.     SearchPictureHeader( nParams );
  441.     // Now call DecodePictureEx that will decode the previous
  442.     // picture retrieving any references needed.
  443.     // Parse the start code so
  444.     ui32 dword;
  445.     GetFordDWord(&dword);
  446.     // Decode without forcing to retrieve the first availabe picture
  447.     DecodePictureEx(DECEX_PREV_PICTURE|DECEX_FORCEDECODING);
  448.  
  449.     // Reset the current timestamps because they are not valid at all.
  450.     p.forward.PTS = p.backward.PTS = 0;
  451.     p.forward.SCR = p.backward.SCR = 0;
  452.  
  453.     memset(&myPES, 0, sizeof(PESinfo));
  454.     // Now set the position back again to the sync point
  455.     CDemux::SetStreamPos( opt->nSyncPoint );
  456.     // Flag sync Decoding operation. i.e. only calls to getFrame can be performed.
  457.     m_bSyncedDecoding = true;
  458.     // Flush the buffer
  459.     FlushBuffer();
  460.     
  461.     //Read Linear PES init
  462.     StartReadLPES();
  463.     // Store the end point
  464.     m_nEndPoint = opt->nEndPoint;
  465.     if(m_nEndPoint <= opt->nSyncPoint)
  466.       m_nEndPoint = GetStreamSize();
  467.  
  468.     // That should do it!
  469.   }
  470.   else
  471.   {
  472.     m_bSyncedDecoding = false;
  473.   }
  474.     // Subpic init
  475.   if( subpic_streamID!=-1 )
  476.       subpic_init(pClut);
  477.  
  478.     return 1;
  479. }
  480.  
  481.  
  482. i64 inline VideoWrapper::get_time(int adjust_clock)
  483. {
  484.     i64    present;
  485.     i64    delay = (__int64)(MPEG2_CLK_REF*(frameDelay));
  486.     ui32  half_delay = (int)delay>>1;
  487.  
  488.  
  489.     if(p.image.PTS){
  490. #if DEBUG
  491.     if( ABS(internalPTS - p.image.PTS) > 900000 ) 
  492.       DBG_STR((str, "VideoWrapper::get_time() - Timestamp deviates from expected value by %I64d clock units or %I64d ms\n", internalPTS - p.image.PTS, (internalPTS - p.image.PTS)/27000));
  493. #endif
  494.         internalPTS = p.image.PTS;
  495.         switch( adjust_clock )
  496.         {
  497.             case EQUAL:
  498.                 present = internalPTS;
  499.                 break;
  500.             case PLUS:
  501.                 present = internalPTS = internalPTS + half_delay;
  502.                 break;
  503.             case MINUS:
  504.                 present = internalPTS = internalPTS - half_delay;
  505.                 break;
  506.         }
  507.  
  508.             internalPTS += i64(recons_progressive ? (1.25*(double)delay) : delay);    
  509.  
  510.     }
  511.     else{
  512.             present = internalPTS;
  513.             internalPTS += i64(recons_progressive ? (1.25*(double)delay) : delay);    
  514.     }
  515.     return present;
  516. }
  517.  
  518. // CFrame GetFrame
  519. // Frame source definition
  520. bool VideoWrapper::GetFrame(CFrame **pFrame)
  521. {
  522.   int nVal;
  523.   *pFrame = NULL;
  524.  
  525.   if( m_nLastDecodedPictureStart >= m_nEndPoint &&
  526.       m_bSyncedDecoding)
  527.     return false;  
  528.  
  529.     ui32  frame_delay = (ui32)(frameDelay * 10000.0);
  530.   ui32  progressive_frame_delay = (ui32)(1.25 * frameDelay * 10000.0);
  531.  
  532.  
  533.   if(!m_pFrontFrame)
  534.   {
  535.     m_pFrontFrame = m_pFrameBuffer->GetFreeFrame();
  536.     if(!m_pFrontFrame)
  537.       return false;
  538.   }
  539.  
  540.   if(!m_pBackFrame)
  541.   {
  542.     m_pBackFrame  = m_pFrameBuffer->GetFreeFrame();
  543.     if(!m_pBackFrame)
  544.       return false;
  545.   }
  546.  
  547.   
  548.   // If we already have a frame
  549.   // return it
  550.   if(m_bFronFrameIsReady)
  551.   {
  552.     *pFrame       = m_pFrontFrame;
  553.     m_pFrontFrame = m_pBackFrame;
  554.     m_pBackFrame  = NULL;
  555.     m_bFronFrameIsReady = false;
  556.     goto EndGetFrame;
  557.   }
  558.  
  559.   m_pFrontFrame->SetDuration( frame_delay );
  560.  
  561.   // Retrieve a frame
  562.   nVal = get_frame();
  563.   if(!nVal)
  564.     return false;
  565.  
  566.   
  567.   // Parse frame structure
  568.     if(progressive_sequence)
  569.   {
  570.         //Well, here MPEG2 standard defines 
  571.         // to output 1, 2 or 3 consecutive frames
  572.         // for 60 fps progressive output
  573.         // let's output just one
  574.         // This is the case of MPEG1 too
  575.     m_pFrontFrame->SetFrame(m_pDecoded);
  576.     m_pFrontFrame->SetPresTime( get_time(EQUAL) );
  577.     m_pFrontFrame->SetFlags( FRAME_PROGRESSIVE );
  578.  
  579.     *pFrame       = m_pFrontFrame;
  580.     m_pFrontFrame = m_pBackFrame;
  581.     m_pBackFrame  = NULL;
  582.     }
  583.   else
  584.   {
  585.         if(p.image.progressive_frame)
  586.         {
  587.             if(recons_progressive)
  588.       {
  589.         m_pFrontFrame->SetFrame(m_pDecoded);
  590.         m_pFrontFrame->SetPresTime( get_time(EQUAL) );
  591.         m_pFrontFrame->SetFlags( FRAME_PROGRESSIVE );
  592.         m_pFrontFrame->SetDuration( progressive_frame_delay );
  593.  
  594.         *pFrame       = m_pFrontFrame;
  595.         m_pFrontFrame = m_pBackFrame;
  596.         m_pBackFrame  = NULL;        
  597.         m_bTopFieldExpected = true;
  598.             }
  599.             else if(p.image.top_field_first)
  600.       {
  601.         m_pFrontFrame->SetFrame(m_pDecoded);
  602.         m_pFrontFrame->SetPresTime( get_time(EQUAL) );
  603.         m_pFrontFrame->SetFlags( FRAME_INTERLACED );
  604.  
  605.                 if(p.image.repeat_first_field )
  606.         {
  607.           m_pBackFrame->SetField(m_pDecoded, true);
  608.           m_pBackFrame->SetFlags( FRAME_TOPFIELD );
  609.           m_bTopFieldExpected = false;
  610.                 }
  611.         else
  612.           m_bTopFieldExpected = true;
  613.  
  614.         *pFrame       = m_pFrontFrame;
  615.         m_pFrontFrame = m_pBackFrame;
  616.         m_pBackFrame  = NULL;        
  617.       }
  618.             else //Bottom field first
  619.       {
  620.  
  621.         m_pFrontFrame->SetField(m_pDecoded, false);
  622.         m_pFrontFrame->SetPresTime( get_time(MINUS) );
  623.         m_pFrontFrame->SetFlags( FRAME_INTERLACED );
  624.  
  625.                 if(m_bTopFieldExpected)
  626.           m_pFrontFrame->SetField(m_pDecoded, true);
  627.  
  628.         m_pBackFrame->SetField(m_pDecoded, true);
  629.         if(p.image.repeat_first_field )
  630.         {
  631.           m_pBackFrame->SetField(m_pDecoded, false);
  632.           m_pBackFrame->SetPresTime( get_time(PLUS) );
  633.           m_bFronFrameIsReady = true;
  634.           m_bTopFieldExpected = true;
  635.         }
  636.         else
  637.           m_bTopFieldExpected = false;
  638.  
  639.         *pFrame       = m_pFrontFrame;
  640.         m_pFrontFrame = m_pBackFrame;
  641.         m_pBackFrame  = NULL;    
  642.             }
  643.     } 
  644.         else // Frame is interlaced
  645.     {
  646.             if( p.image.picture_structure == FRAME_PICTURE )
  647.       {
  648.                 if(p.image.top_field_first)
  649.         {
  650.           m_pFrontFrame->SetFrame(m_pDecoded);
  651.           m_pFrontFrame->SetPresTime( get_time(EQUAL) );
  652.           m_pFrontFrame->SetFlags( FRAME_INTERLACED );
  653.  
  654.           *pFrame       = m_pFrontFrame;
  655.           m_pFrontFrame = m_pBackFrame;
  656.           m_pBackFrame  = NULL; 
  657.           m_bTopFieldExpected = true;
  658.                 }
  659.                 else //bottom field first
  660.         {
  661.           m_pFrontFrame->SetField(m_pDecoded, false);
  662.           m_pFrontFrame->SetPresTime( get_time(MINUS) );
  663.           m_pFrontFrame->SetFlags( FRAME_INTERLACED );
  664.  
  665.           if(m_bTopFieldExpected)
  666.             m_pFrontFrame->SetField(m_pDecoded, true);
  667.           
  668.           m_pBackFrame->SetField(m_pDecoded, true);
  669.  
  670.           *pFrame       = m_pFrontFrame;
  671.           m_pFrontFrame = m_pBackFrame;
  672.           m_pBackFrame  = NULL; 
  673.           m_bTopFieldExpected = false;
  674.                 }
  675.             }
  676.             else // frames is reconstructed from field pictures
  677.       {
  678.         if(p.image.top_field_first)
  679.         {
  680.           m_pFrontFrame->SetFrame(m_pDecoded);
  681.           m_pFrontFrame->SetPresTime( get_time(EQUAL) );
  682.           m_pFrontFrame->SetFlags( FRAME_INTERLACED );
  683.           
  684.           *pFrame       = m_pFrontFrame;
  685.           m_pFrontFrame = m_pBackFrame;
  686.           m_pBackFrame  = NULL;
  687.           m_bTopFieldExpected = true;
  688.         }
  689.         else //bottom field first
  690.         {
  691.           m_pFrontFrame->SetField(m_pDecoded, false);
  692.           m_pFrontFrame->SetPresTime( get_time(MINUS) );
  693.           m_pFrontFrame->SetFlags( FRAME_INTERLACED );
  694.           
  695.           if(m_bTopFieldExpected)
  696.             m_pFrontFrame->SetField(m_pDecoded, true);
  697.           
  698.           m_pBackFrame->SetField(m_pDecoded, true);
  699.           
  700.           *pFrame       = m_pFrontFrame;
  701.           m_pFrontFrame = m_pBackFrame;
  702.           m_pBackFrame  = NULL; 
  703.           m_bTopFieldExpected = false;
  704.         }
  705.             }    
  706.         }
  707.     }
  708.  
  709. EndGetFrame:
  710.   // Apply subpictures
  711.   if( subpic_streamID!=-1 )
  712.     subpic_apply(*pFrame, (double)(*pFrame)->GetPresTime()/27000.0);
  713.  
  714. ;
  715.   return true;
  716. }
  717.  
  718. bool VideoWrapper::GetBackByte(ui8 *byte)
  719. {
  720.     bool bSuccess = true;
  721.   PESinfo dummyPES;
  722.  
  723.     // The offset has to be 
  724.     if( m_nTempVideoBufferPtr <= (i32)m_nTempVideoBufferSize )
  725.     {
  726.         // Grab previous PES if we're finished with this one
  727.         // or we don't have any data
  728.         if( m_nTempVideoBufferPtr <= 0 || !m_pTempVideoBuffer )
  729.         {
  730.             // The buffer has been underrun.
  731.             // Retrieve the previous buffer. This assumes that the position in the
  732.             // stream is exactly the byte after the latest PES.
  733.  
  734.             // Rewind PES
  735.             // If the pointer of the file is at the end
  736.             // of the Pes rewind this PES first
  737.             if( m_nPesPosState == PesEnd )
  738.                 bSuccess = RewindPreviousPES( streamID );
  739.             // Rewind again to find the real Pes
  740.             bSuccess = RewindPreviousPES( streamID );
  741.             ui64 PESpos = CDemux::GetStreamPos();
  742.  
  743.             if( bSuccess )
  744.             {
  745.                 // Read the PES
  746.                 // Invalid value for streamId
  747.                 dummyPES.streamID = 0xAA;
  748.                 while( bSuccess && dummyPES.streamID!=streamID )
  749.                 {
  750.                     bSuccess = ReadPES( (unsigned char **)&m_pTempVideoBuffer, &dummyPES );
  751.                     if( bSuccess )
  752.                     {
  753.                         m_nTempVideoBufferSize = dummyPES.payloadSize;
  754.                         m_nTempVideoBufferPtr  = dummyPES.payloadSize;
  755.                         // Update this two variables to be able to
  756.                         // reposition the stream after this.
  757.                         m_nPesPosState = PesBegin;
  758.                         m_nEndPesPosition = CDemux::GetStreamPos();
  759.                     }
  760.                 }
  761.                 // Because we want to emulate the going backwards 
  762.                 // behaviour, set the position to the beginning of the PES
  763.                 // again
  764.                 CDemux::SetStreamPos( PESpos );
  765.             }
  766.             else
  767.                 DBG_STR((str, "VideoWrapper::GetBackByte() - Couldnt rewind PES\n"));
  768.         }
  769.  
  770.         // There are still bytes in this buffer to gather.
  771.         if( bSuccess )
  772.         {    
  773.             m_nTempVideoBufferPtr--;
  774.             *byte = *(m_pTempVideoBuffer + m_nTempVideoBufferPtr);
  775.         }        
  776.     }
  777.     else
  778.     {
  779.         DBG_STR((str, "VideoWrapper::GetBackByte() - Buffer offset outside bounds\n"))
  780.         bSuccess = false;
  781.     }
  782.     return bSuccess;
  783. }
  784.  
  785. bool VideoWrapper::GetFordByte(ui8 *byte)
  786. {
  787.     bool    bSuccess = true;
  788.   PESinfo dummyPES;
  789.  
  790.     // The offset has to be minor than the buffer size
  791.     if( m_nTempVideoBufferPtr <= (i32)m_nTempVideoBufferSize )
  792.     {
  793.         // Grab previous PES if we're finished with this one
  794.         if( m_nTempVideoBufferPtr >= (i32)m_nTempVideoBufferSize || !m_pTempVideoBuffer)
  795.         {
  796.             // Read the PES
  797.             // If the pointer is a the beginning of the Pes
  798.             // We just read, read it again to parse it. 
  799.             if( m_nPesPosState == PesBegin )
  800.                 bSuccess = ReadPES( (unsigned char **)&m_pTempVideoBuffer, &dummyPES );
  801.  
  802.             // Invalid value for streamId
  803.             dummyPES.streamID = 0xAA;
  804.             while( bSuccess && dummyPES.streamID!=streamID )
  805.             {
  806.                 bSuccess = ReadPES( (unsigned char **)&m_pTempVideoBuffer, &dummyPES );
  807.                 if( bSuccess && dummyPES.streamID==streamID )
  808.                 {
  809.                     m_nPesPosState = PesEnd;
  810.                     m_nTempVideoBufferSize = dummyPES.payloadSize;
  811.                     m_nTempVideoBufferPtr  = 0;                    
  812.                 }
  813.             }
  814.         }
  815.         // There are still bytes in this buffer to gather.
  816.         if( bSuccess )
  817.         {
  818.             *byte = *(m_pTempVideoBuffer + m_nTempVideoBufferPtr);
  819.             m_nTempVideoBufferPtr++;            
  820.         }        
  821.     }
  822.     else
  823.     {
  824.         bSuccess = false;
  825.     }
  826.     return bSuccess;
  827.             
  828. }
  829. bool VideoWrapper::GetFordDWord(ui32 *dword)
  830. {
  831.     ui8 byte;
  832.  
  833.     *dword = 0;
  834.  
  835.     bool bSuccess = GetFordByte( &byte );
  836.     *dword = byte << 24;
  837.     if( bSuccess )
  838.         bSuccess = GetFordByte( &byte );
  839.     *dword |= byte << 16;
  840.     if( bSuccess )
  841.         bSuccess = GetFordByte( &byte );
  842.     *dword |= byte << 8;        
  843.     if( bSuccess )
  844.         bSuccess = GetFordByte( &byte );
  845.     *dword |= byte;    
  846.     
  847.     return bSuccess;
  848. }
  849.  
  850. bool VideoWrapper::SearchPictureHeader( int &nParams )
  851. {
  852.     bool bSuccess=true;
  853.     bool bFound = false;
  854.    i32 nParsedBytes;
  855.   ui32 nPictureType;
  856.   ui32 nPrevPictureType;
  857.   ui32 nTemporalReference;
  858.   ui64 nFirstFieldPictureStartPos=0;
  859.   bool bLookingSecondField=false;
  860.   ui32 nPrevTemporalReference;
  861.   ui16 nVBVDelay;
  862.   ui8  nPictureStructure;
  863.     
  864.     ui8  byte;
  865.     
  866.     while( !bFound && bSuccess )
  867.     {
  868.         ui32 nStartCode = 0xFFFFFFFF;
  869.         
  870.         // Select direccion of search
  871.         if( nParams&SEARCH_BACKWARDS )
  872.             while( nStartCode!=PICTURE_START_CODE && bSuccess )
  873.             {
  874.                 bSuccess = GetBackByte(&byte);
  875.                 nStartCode = (nStartCode>>8) | (byte<<24);
  876.             }
  877.             else
  878.                 while( nStartCode!=PICTURE_START_CODE && bSuccess )
  879.                 {
  880.                     bSuccess = GetFordByte(&byte);
  881.                     nStartCode = (nStartCode<<8) | byte;
  882.                 }
  883.                 
  884.                 if( bSuccess )
  885.                 {
  886.                     // We found a picture header and we are aligned with it
  887.                     // Get start code
  888.                     // Only parse the start code if we were reading
  889.                     // backwards
  890.  
  891.                     if( nParams&SEARCH_BACKWARDS )
  892.                         GetFordDWord(&nStartCode);
  893.  
  894.                     GetFordByte(&byte);
  895.           nTemporalReference = byte << 2;
  896.                     GetFordByte(&byte);
  897.           nTemporalReference |= (byte&0xC0)>>6;
  898.  
  899.           nParsedBytes = 6;
  900.                     nPictureType = (byte&0x3F)>>3;
  901.  
  902.           // If we're not interested in this type
  903.           // continue searching
  904.  
  905. #define FOUND_TYPE  ((nPictureType==P_TYPE && nParams&SEARCH_P) ||  \
  906.                      (nPictureType==B_TYPE && nParams&SEARCH_B) ||  \
  907.                      (nPictureType==I_TYPE && nParams&SEARCH_I) )
  908.  
  909. #if 0
  910.           char cTypes[] = {'X','I','P','B','X','X','X','X','X','X','X','X','X','X','X','X'};
  911.           DBG_STR((str, "VideoWrapper::SearchPictureHeader - %c picture found at %d\n", cTypes[nPictureType], GetStreamPos()-6))
  912. #endif
  913.         
  914.           if( nParams&SEARCH_ALIGN_FIRST_FIELD )
  915.           {
  916.             // parse the rest of the header
  917.             nVBVDelay  = (byte&0x07)<<13;
  918.             GetFordByte(&byte);
  919.             nVBVDelay |= byte<<5;
  920.             GetFordByte(&byte);
  921.             nVBVDelay |= (byte&0xF8)>>3;
  922.  
  923.             nParsedBytes += 2;
  924.             // Keep track of the bits remaining in 'byte'
  925.             // Now we have 3 bits remaining.
  926.             ui32 nBitsRemaining = 3;
  927.  
  928.  
  929. #define Rewind(x) { for(int i=0; i<x; i++) GetBackByte(&byte); }
  930.  
  931.             // Find next start code prefix
  932.             ui32 nStartCode = 0xFFFFFF00;
  933.             while( (nStartCode&0x00FFFFFF)!=1 && bSuccess )
  934.             {
  935.               bSuccess = GetFordByte(&byte);
  936.               nParsedBytes += 1;
  937.               nStartCode = (nStartCode<<8) | byte;
  938.             }
  939.  
  940.             if(!bSuccess) continue;
  941.             GetFordByte(&byte);
  942.             nParsedBytes += 1;
  943.             if(byte!=0xB5)
  944.             {
  945.               // Either this is MPEG1 or something wrong happened
  946.               goto validate;
  947.             }
  948.  
  949.             GetFordByte(&byte);
  950.             if((byte>>4)!=8) // The extension_start_code_identifier is 8 for picture
  951.               continue;      // something wrong happened
  952.  
  953.             nParsedBytes += 1;
  954.             GetFordByte(&byte); // parse some stuff
  955.             GetFordByte(&byte);
  956.             nParsedBytes += 2;
  957.             nPictureStructure = byte&0x03;
  958.  
  959.             bool bJumpToPos = false;
  960.             if(nPictureStructure==FRAME_PICTURE){
  961.               if(FOUND_TYPE)
  962.               {
  963.                 bFound = true;
  964.                 SetSearchType( nParams, nPictureType );
  965.               }
  966.             }
  967.             else{// we have a field picture
  968.               if( !bLookingSecondField ){
  969.                 nFirstFieldPictureStartPos = GetStreamPos() - nParsedBytes;
  970.                 nPrevTemporalReference = nTemporalReference;
  971.                 nPrevPictureType       = nPictureType;
  972.                 bLookingSecondField = true;
  973.               }
  974.               else
  975.               {
  976.                 // In this two field pictures, the temporal reference
  977.                 // matches. These two form the frame picture. Position
  978.                 // ourselves in the first one.                
  979.                 if( nPrevTemporalReference==nTemporalReference ){
  980.                   // If we're going forward, it was the previous one
  981.                   if(nParams&SEARCH_FORWARD)
  982.                   {
  983.                     bJumpToPos = true;
  984.                     nPictureType = nPrevPictureType;
  985.                   }
  986.                 }
  987.                 else{
  988.                   if(nParams&SEARCH_BACKWARDS)
  989.                   {
  990.                     bJumpToPos = true;
  991.                     nPictureType = nPrevPictureType;
  992.                   }
  993.                 }
  994.                 Second_Field = 0;
  995.                 if(FOUND_TYPE)
  996.                 {
  997.                   SetSearchType( nParams, nPictureType );                  
  998.                   bFound = true;
  999.                 }
  1000.                 bLookingSecondField = false;
  1001.               }
  1002.             }
  1003.             if(bFound || nParams&SEARCH_BACKWARDS)
  1004.             {
  1005.               if(bJumpToPos)
  1006.                   SetStreamPos(nFirstFieldPictureStartPos);
  1007.               else
  1008.                   Rewind(nParsedBytes);
  1009.             }
  1010.  
  1011.           }
  1012.           else
  1013.           {
  1014. validate:
  1015.             if(FOUND_TYPE)
  1016.             {
  1017.               bFound = true;
  1018.               SetSearchType( nParams, nPictureType );
  1019.             }
  1020.             if( bFound || nParams&SEARCH_BACKWARDS )
  1021.             {
  1022.               Rewind(nParsedBytes);
  1023.             }              
  1024.           }
  1025.         }
  1026.     }
  1027.     return bSuccess;
  1028. }
  1029.  
  1030. bool VideoWrapper::EnterCoreContext()
  1031. {
  1032.     Set_Buffer_State( m_pTempVideoBuffer, 
  1033.                       m_nTempVideoBufferPtr, 
  1034.                       m_nTempVideoBufferSize );
  1035.     return true;
  1036. }
  1037.  
  1038. bool VideoWrapper::ExitCoreContext()
  1039. {
  1040.     m_nTempVideoBufferPtr = Get_Buffer_Pos();
  1041.   // If the pos is <0 means that the current position
  1042.   // of the video buffer belongs to a previous buffer
  1043.   // Rewind it
  1044.   if( m_nTempVideoBufferPtr<0 )
  1045.   {
  1046.     int nRewindBytes = -m_nTempVideoBufferPtr;
  1047.     // Set the beginning of the buffer
  1048.     m_nTempVideoBufferPtr = 0;
  1049.     // Rewind
  1050.     ui8 byte;
  1051.     for(int i=0; i<nRewindBytes; i++) 
  1052.       GetBackByte(&byte);
  1053.   }
  1054.     return true;
  1055. }
  1056.  
  1057.  
  1058. ////////////////////////////////////////////////////////////////////////////////
  1059. //
  1060. // Navigational retrieving methods. Timestamps are not valid within this context.
  1061. //
  1062. ////////////////////////////////////////////////////////////////////////////////
  1063.  
  1064. void VideoWrapper::UpdateDecodedPtr()
  1065. {
  1066.   unsigned char *pDecoded;
  1067.   pDecoded = p.actual.picture_coding_type==B_TYPE ? auxframe[0] : forward_reference_frame[0];
  1068.  
  1069.   for(int i=0; i<3; i++)
  1070.     if( pDecoded==(unsigned char *)m_frRef[i].GetBuffer() )
  1071.       break;
  1072.  
  1073.   m_pDecoded = &m_frRef[i];
  1074.  
  1075.   // Update picture info
  1076.   p.image = p.actual.picture_coding_type==B_TYPE ? p.actual : p.forward;
  1077. }
  1078.  
  1079. //-------------------------------------------------------------------
  1080. // GetSingleFrame - pFrame should be copied and not used directly.
  1081. //-------------------------------------------------------------------
  1082. inline bool VideoWrapper::GetSingleFrame(CFrame **pFrame, int nFlags)
  1083. {
  1084.  
  1085.   DecodePictureEx(nFlags);
  1086.   UpdateDecodedPtr();
  1087.  
  1088.   if(m_bReadError)
  1089.     error=END_OF_STREAM;
  1090.  
  1091.   bool bSuccess =!m_bReadError;
  1092.   if(!bSuccess)
  1093.   {
  1094.     *pFrame = NULL;
  1095.     return false;
  1096.   }
  1097.  
  1098.   *pFrame = m_pDecoded;
  1099.   return false;
  1100. }
  1101.  
  1102.  
  1103. bool VideoWrapper::GetNextFrame( CFrame **pFrame )
  1104. { 
  1105.   return GetSingleFrame(pFrame, DECEX_NEXT_PICTURE);
  1106. }
  1107.  
  1108. bool VideoWrapper::GetPrevFrame( CFrame **pFrame )
  1109. { 
  1110.   return GetSingleFrame(pFrame, DECEX_PREV_PICTURE);
  1111. }
  1112.  
  1113. bool VideoWrapper::GetNextIFrame(CFrame **pFrame)
  1114. {
  1115.   return GetSingleFrame(pFrame, DECEX_NEXT_PICTURE|DECEX_JUST_IPICTURE);
  1116. }
  1117.  
  1118. bool VideoWrapper::GetPrevIFrame(CFrame **pFrame)
  1119. {
  1120.   return GetSingleFrame(pFrame, DECEX_PREV_PICTURE|DECEX_JUST_IPICTURE);
  1121. }
  1122.  
  1123.  
  1124. int VideoWrapper::DecodePictureEx( int nDecExParams )
  1125. {
  1126.     int nRetValue=0;
  1127.     int nPictureTypes, nDecodingModes;
  1128.     int nParams;
  1129.     
  1130.     nPictureTypes = nDecExParams&DECEX_JUST_IPICTURE ? 
  1131.                     SEARCH_I : 
  1132.                     SEARCH_I | SEARCH_B | SEARCH_P;
  1133.  
  1134.     // If just I picture was demanded, skip references search
  1135.     nDecodingModes = nDecExParams&DECEX_JUST_IPICTURE ? 
  1136.                      SKIP_REF_SEARCH|DECODING_PICTURE : DECODING_PICTURE;
  1137.  
  1138.     if( nDecExParams&DECEX_NEXT_PICTURE )
  1139.     {
  1140.         nParams = nPictureTypes | SEARCH_FORWARD | SEARCH_ALIGN_FIRST_FIELD;
  1141.         if( SearchPictureHeader( nParams ) )
  1142.         {
  1143.             if( m_bFirstPictureDecoded )
  1144.             {
  1145.               nDecodingModes |= SKIP_REF_SEARCH;
  1146.               nRetValue = DecodePicture(nDecodingModes);
  1147.             }
  1148.             else
  1149.             {
  1150.                 m_bFirstPictureDecoded = true;
  1151.                 nRetValue = DecodePicture(nDecodingModes);
  1152.                 // This is here in the case of an I frame. Likely the first
  1153.                 // of the stream 
  1154.                 // Decode next picture. Should be a P.
  1155.                 while( nRetValue==DEC_NOTENOUGHREF && 
  1156.                        !m_bReadError &&
  1157.                        !(nDecExParams&DECEX_FORCEDECODING)) // this will return DEC_NOTENOUGHREF
  1158.                     nRetValue=DecodePicture(nDecodingModes);
  1159.             }
  1160.             m_bPreviousDirWasForward = true;
  1161.         }
  1162.     }
  1163.     else
  1164.     {
  1165.         // Now rewind picture just decoded
  1166.         nParams = nPictureTypes | SEARCH_BACKWARDS | SEARCH_ALIGN_FIRST_FIELD;
  1167.         SearchPictureHeader( nParams );
  1168.         
  1169.         nParams = nPictureTypes | SEARCH_BACKWARDS | SEARCH_ALIGN_FIRST_FIELD;
  1170.         DBG_STR((str, "VideoWrapper::DecodePictureEx - back decoding starting at %d\n", GetStreamPos()))        
  1171.         if( SearchPictureHeader( nParams ) )
  1172.         {
  1173.             m_bFirstPictureDecoded = false;
  1174.             nRetValue = DecodePicture(nDecodingModes);
  1175.             // This is here in the case of an I frame. Likely the first
  1176.             // of the stream 
  1177.             // Decode next picture. Should be a P.
  1178.             while( nRetValue==DEC_NOTENOUGHREF && 
  1179.                   !m_bReadError &&
  1180.                   !(nDecExParams&DECEX_FORCEDECODING)) // this will return DEC_NOTENOUGHREF
  1181.               nRetValue=DecodePicture(nDecodingModes);
  1182.         }
  1183.         //DBG_STR((str, "VideoWrapper::DecodePictureEx - back decoding stopping at %d\n", GetStreamPos()))
  1184.         m_bPreviousDirWasForward = false;
  1185.     }
  1186.     // If just and I picture was demanded, reposition the stream
  1187.     // to the frame after the next I or P picture, because DECEX_JUST_IPICTURE makes
  1188.     // the decoder to output the I picture without references.
  1189.     if( nDecExParams&DECEX_JUST_IPICTURE )
  1190.     {
  1191.       // Search the next I or P
  1192.       nParams = SEARCH_P | SEARCH_I | SEARCH_FORWARD | SEARCH_ALIGN_FIRST_FIELD;
  1193.       SearchPictureHeader( nParams );
  1194.       // Get one byte to avoid aligning to the I or P again
  1195.       ui8 byte;
  1196.       GetFordByte(&byte);
  1197.       // Align to the frame after it
  1198.       nParams = SEARCH_P | SEARCH_I | SEARCH_B | SEARCH_FORWARD | SEARCH_ALIGN_FIRST_FIELD;
  1199.       SearchPictureHeader( nParams );       
  1200.     }
  1201.  
  1202.     return nRetValue;
  1203. }
  1204.  
  1205. int VideoWrapper::DecodePicture(int nDecParams)
  1206. {
  1207.     ui64 nPicturePos;
  1208.     int  nParams, cc;
  1209.     unsigned char *tmp;  /* temporary swap pointer */
  1210.     bool bSuccess;
  1211.   int  nReturn = DEC_OK;
  1212.     
  1213.   // Our goal is to decode the picture that is this position.
  1214.   // Parse picture header
  1215.   nParams  = SEARCH_P | SEARCH_I | SEARCH_B | SEARCH_FORWARD | SEARCH_ALIGN_FIRST_FIELD;
  1216.   if(!(nDecParams&SKIP_REF_SEARCH))
  1217.   {
  1218.     if( SearchPictureHeader( nParams )  )
  1219.     {
  1220.       // If we are told NOT to search
  1221.       // for references skip this section.
  1222.       // This is flagged when we already have
  1223.       // the correct references.
  1224.       
  1225.       // Retrieve position of this picture
  1226.       nPicturePos = GetStreamPos();
  1227.       
  1228.       switch( GetSearchType( nParams ) )
  1229.       {
  1230.       case I_TYPE:
  1231.         // No references pictures needed. Decode picture right away.
  1232.         // However the output will be the previous I or P
  1233.         // Retrieve it only if we this is the first call to DecodePicture,
  1234.         // i.e. we're not doing recursive calls to DecodePicture to retrieve 
  1235.         // references.
  1236.         // Backward reference needed
  1237.         if( nDecParams&DECODING_PICTURE )
  1238.         {
  1239.           nParams = SEARCH_I | SEARCH_P | SEARCH_BACKWARDS | SEARCH_ALIGN_FIRST_FIELD;
  1240.           if( SearchPictureHeader( nParams ) )
  1241.             // We found the previous P or I picture. Decode it.
  1242.             nReturn = DecodePicture();
  1243.           else
  1244.             nReturn = DEC_NOTENOUGHREF;
  1245.         }
  1246.         break;            
  1247.       case P_TYPE:
  1248.         // Backward reference needed
  1249.         nParams = SEARCH_I | SEARCH_P | SEARCH_BACKWARDS  | SEARCH_ALIGN_FIRST_FIELD;
  1250.         if( SearchPictureHeader( nParams ) )
  1251.         {
  1252.           // We found the previous P or I picture. Decode it.
  1253.           nReturn = DecodePicture();
  1254.           // Put this P or I frame as reference 
  1255.         }
  1256.         else
  1257.           nReturn = DEC_NOTENOUGHREF;
  1258.         // Rewind stream to find previous I or P picture.
  1259.         // Decode it and put it as reference. Come back to this place.
  1260.         break;
  1261.       case B_TYPE:
  1262.         ui64 nFirstRefPos = -1;
  1263.         bool bFirstRefOk=false, bSecondRefOk=false;
  1264.         // Search for the previous I or P
  1265.         nParams = SEARCH_P | SEARCH_I | SEARCH_BACKWARDS  | SEARCH_ALIGN_FIRST_FIELD;
  1266.         bSuccess = SearchPictureHeader( nParams );
  1267.         if(bSuccess)
  1268.         {
  1269.           nFirstRefPos = GetStreamPos();
  1270.           
  1271.           // Search for the previous I or P picture again
  1272.           nParams = SEARCH_P | SEARCH_I | SEARCH_BACKWARDS  | SEARCH_ALIGN_FIRST_FIELD;
  1273.           bSuccess = SearchPictureHeader( nParams );
  1274.           if( bSuccess )
  1275.             bFirstRefOk = DecodePicture()!=DEC_NOTENOUGHREF;
  1276.         }
  1277.         // If we found the first reference decode it
  1278.         if( nFirstRefPos != -1 )
  1279.         {
  1280.           // Set the stream to the first reference
  1281.           // we found
  1282.           SetStreamPos( nFirstRefPos );
  1283.           // Decode it
  1284.           bSecondRefOk = DecodePicture()!=DEC_NOTENOUGHREF;
  1285.         }
  1286.         
  1287.         nReturn = ( bSuccess && bFirstRefOk && bSecondRefOk ) ? DEC_OK : DEC_NOTENOUGHREF;
  1288.         break;
  1289.       }
  1290.       
  1291.       // Restore position of the beginning of this picture
  1292.       SetStreamPos( nPicturePos );
  1293.     }
  1294.   } 
  1295.  
  1296.   if(!Second_Field)
  1297.     m_nLastDecodedPictureStart = GetStreamPos();
  1298.   
  1299.   // Don't enter and exit context if we are in continous reading mode!
  1300.   if(!(nDecParams&CONTINOUS_READING))  
  1301.     EnterCoreContext();
  1302.  
  1303.   // We should be align to the first field by now.
  1304.   Second_Field = 0;
  1305.   
  1306. start_decode:
  1307.   if(Get_Hdr())
  1308.   {
  1309.     if (picture_structure==FRAME_PICTURE && Second_Field)
  1310.     {
  1311.       DBG_STR((str, "VideoWrapper::DecodePicture - Odd number of field pictures\n"));
  1312.       Second_Field = 0;
  1313.     }            
  1314.  
  1315.     if( !(nDecParams&DONT_UPDATE_REF) )
  1316.     {
  1317.       // DBG_STR((str, "VideoWrapper::DecodePicture - pic type %d  sec field %d\n", picture_coding_type,Second_Field));
  1318.       // Update picture buffers
  1319.       for (cc=0; cc<3; cc++)
  1320.       {
  1321.         /* B pictures do not need to be saved for future reference */
  1322.         if (picture_coding_type==B_TYPE)
  1323.         {
  1324.           current_frame[cc] = auxframe[cc];
  1325.         }
  1326.         else
  1327.         {
  1328.           /* only update at the beginning of the coded frame */
  1329.           if (!Second_Field)
  1330.           {
  1331.             tmp = forward_reference_frame[cc];
  1332.             
  1333.             /* the previously decoded reference frame is stored
  1334.             coincident with the location where the backward 
  1335.             reference frame is stored (backwards prediction is not
  1336.             needed in P pictures) */
  1337.             forward_reference_frame[cc] = backward_reference_frame[cc];
  1338.             
  1339.             /* update pointer for potential future B pictures */
  1340.             backward_reference_frame[cc] = tmp;                
  1341.           }
  1342.           
  1343.           /* can erase over old backward reference frame since it is not used
  1344.           in a P picture, and since any subsequent B pictures will use the 
  1345.           previously decoded I or P frame as the backward_reference_frame */
  1346.           current_frame[cc] = backward_reference_frame[cc];
  1347.         }
  1348.         /* IMPLEMENTATION:
  1349.         one-time folding of a line offset into the pointer which stores the
  1350.         memory address of the current frame saves offsets and conditional 
  1351.         branches throughout the remainder of the picture processing loop */
  1352.         if (picture_structure==BOTTOM_FIELD)
  1353.           current_frame[cc]+= (cc==0) ? Coded_Picture_Width : Chroma_Width;
  1354.       }
  1355.     }
  1356.     // Finally decode the picture data
  1357.     picture_data();
  1358.     
  1359.     if (picture_structure!=FRAME_PICTURE)
  1360.       Second_Field = !Second_Field;
  1361.  
  1362.     if (picture_structure!=FRAME_PICTURE && Second_Field)
  1363.       goto start_decode;
  1364.  
  1365.   }
  1366.   else
  1367.   {
  1368.     DBG_STR((str, "VideoWrapper::DecodePicture - GetHdr() failed.\n"));    
  1369.   }
  1370.   // Don't enter and exit context if we are in continous reading mode!
  1371.   if(!(nDecParams&CONTINOUS_READING))    
  1372.     ExitCoreContext();
  1373.  
  1374.   return nReturn;
  1375. }
  1376.  
  1377.  
  1378.  
  1379. bool VideoWrapper::get_frame()
  1380. {  
  1381.     updateVideoStats();
  1382.     
  1383.     time= (ui32)(double(GetTime())/ (double)27000); //miliseconds
  1384.     //In case  there is a problem
  1385.     timeCode.hour= hour;
  1386.     timeCode.minute= minute;
  1387.     timeCode.second= sec;
  1388.     timeCode.frame=  frame;
  1389.     
  1390.     if(stopDecoding){
  1391.         error=PLAYER_STOPPED;
  1392.         return 0;
  1393.     }
  1394.     
  1395.     if(m_bSyncedDecoding)
  1396.     {
  1397.       int nDecodingModes = SKIP_REF_SEARCH|DECODING_PICTURE|CONTINOUS_READING;
  1398.       // Decode an extra picture if we don't have enough references
  1399.       DecodePicture(nDecodingModes);
  1400.  
  1401.     }
  1402.     else
  1403.     {
  1404.       DecodePictureEx(DECEX_NEXT_PICTURE);
  1405.     }
  1406.  
  1407. #ifdef TRACK_FRAMEINFO
  1408.     DBG_STR(( str, "Frame info: Type= %d, Int=%s, TS = %d\n", p.actual.picture_coding_type,
  1409.               p.actual.progressive_frame ? "Yes" : "No",
  1410.               p.actual.PTS / 300));
  1411. #endif
  1412.  
  1413.     UpdateDecodedPtr();
  1414.  
  1415.     if(m_bReadError)
  1416.         error=END_OF_STREAM;
  1417.  
  1418.     return !m_bReadError;
  1419. }
  1420.  
  1421.  
  1422. int VideoWrapper::Stop()
  1423. {
  1424.  
  1425.  
  1426.   if(m_pFrontFrame)
  1427.     m_pFrontFrame->Release();
  1428.   if(m_pBackFrame)  
  1429.     m_pBackFrame->Release();
  1430.  
  1431.     time=0;
  1432.   if( subpic_streamID!=-1 )
  1433.       subpic_free(); /* reset subpics */
  1434.  
  1435.   /* IDCT */
  1436.   if( myVideo->DeInitIdct )
  1437.     myVideo->DeInitIdct();
  1438.     return 0;
  1439. }
  1440.  
  1441. void DeInitClip(){
  1442.     free(Clip-384);
  1443. }
  1444. void InitClip(){
  1445.  
  1446.   int i;
  1447.  
  1448.   /* Clip table */
  1449.   if (!(Clip=(unsigned char *)malloc(1024)))
  1450.     Error("Clip[] malloc failed\n");
  1451.  
  1452.   Clip += 384;
  1453.  
  1454.   for (i=-384; i<640; i++)
  1455.     Clip[i] = (i<0) ? 0 : ((i>255) ? 255 : i);
  1456. }
  1457.  
  1458. /* mostly IMPLEMENTAION specific rouintes */
  1459. void VideoWrapper::InitializeSequence()
  1460. {
  1461.   int size, chroma_size, luma_size;
  1462.   static int Table_6_20[3] = {6,8,12};
  1463.  
  1464.   /* check scalability mode of enhancement layer */
  1465.   if (Two_Streams && (enhan.scalable_mode!=SC_SNR) && (base.scalable_mode!=SC_DP))
  1466.     Error("unsupported scalability mode\n");
  1467.  
  1468.   /* force MPEG-1 parameters for proper decoder behavior */
  1469.   /* see ISO/IEC 13818-2 section D.9.14 */
  1470.   if (!base.MPEG2_Flag)
  1471.   {
  1472.     progressive_sequence = 1;
  1473.     progressive_frame = 1;
  1474.     picture_structure = FRAME_PICTURE;
  1475.     frame_pred_frame_dct = 1;
  1476.     chroma_format = CHROMA420;
  1477.     matrix_coefficients = 5;
  1478.   }
  1479.  
  1480.   /* round to nearest multiple of coded macroblocks */
  1481.   /* ISO/IEC 13818-2 section 6.3.3 sequence_header() */
  1482.   mb_width = (horizontal_size+15)/16;
  1483.   mb_height = (base.MPEG2_Flag && !progressive_sequence) ? 2*((vertical_size+31)/32)
  1484.                                         : (vertical_size+15)/16;
  1485.  
  1486.   Coded_Picture_Width = 16*mb_width;
  1487.   Coded_Picture_Height = 16*mb_height;
  1488.  
  1489.     //Allocate space for Output Bitmap
  1490.    //DibArray=malloc(         Coded_Picture_Width * Coded_Picture_Height * 3 );  
  1491.     //DibArray = TempArray;
  1492.  
  1493.   /* ISO/IEC 13818-2 sections 6.1.1.8, 6.1.1.9, and 6.1.1.10 */
  1494.   Chroma_Width = (chroma_format==CHROMA444) ? Coded_Picture_Width
  1495.                                            : Coded_Picture_Width>>1;
  1496.   Chroma_Height = (chroma_format!=CHROMA420) ? Coded_Picture_Height
  1497.                                             : Coded_Picture_Height>>1;
  1498.   
  1499.   /* derived based on Table 6-20 in ISO/IEC 13818-2 section 6.3.17 */
  1500.   block_count = Table_6_20[chroma_format-1];
  1501.  
  1502.   /* Allocate buffers */
  1503.   chroma_size = Chroma_Width*Chroma_Height;
  1504.   luma_size = Coded_Picture_Width*Coded_Picture_Height;
  1505.   size =  luma_size + 2*(chroma_size);
  1506.  
  1507.   /* Set the format in our frames. This will allocate the space in them */
  1508.   for(int i=0; i<3; i++)
  1509.     m_frRef[i].Set( Coded_Picture_Width, Coded_Picture_Height, FRAME_YV12 );
  1510.  
  1511.   backward_reference_frame[0] = (unsigned char *)m_frRef[0].GetBuffer();
  1512.   forward_reference_frame[0]  = (unsigned char *)m_frRef[1].GetBuffer();
  1513.   auxframe[0]                 = (unsigned char *)m_frRef[2].GetBuffer();;
  1514.  
  1515.   /* Setup pointers */  
  1516.   backward_reference_frame[1] = backward_reference_frame[0] + luma_size + chroma_size;
  1517.   backward_reference_frame[2] = backward_reference_frame[0] + luma_size;
  1518.  
  1519.   forward_reference_frame[1] = forward_reference_frame[0] + luma_size + chroma_size;
  1520.   forward_reference_frame[2] = forward_reference_frame[0] + luma_size;
  1521.  
  1522.   auxframe[1] = auxframe[0] + luma_size + chroma_size;
  1523.   auxframe[2] = auxframe[0] + luma_size;
  1524.  
  1525.  
  1526.  
  1527.  
  1528. }
  1529.  
  1530. void Error(char *text)
  1531. {
  1532.   fprintf(stderr,text);
  1533. //  exit(1);
  1534. }
  1535.  
  1536. /* Trace_Flag output */
  1537. void Print_Bits(int code,int bits,int len)
  1538. {
  1539.   int i;
  1540.   for (i=0; i<len; i++)
  1541.     printf("%d",(code>>(bits-1-i))&1);
  1542. }
  1543.  
  1544.  
  1545. void VideoWrapper::DeinitializeSequence()
  1546. {
  1547.  
  1548.   /* clear flags */
  1549.   base.MPEG2_Flag=0;
  1550. }
  1551.  
  1552.  
  1553.  
  1554.  
  1555. bool VideoWrapper::SetStreamPos(ui64 pos)
  1556. {
  1557.     // Lock the decoder
  1558.     CAutoLock lock(&m_csLockSection);
  1559.   PESinfo   dummyPes;
  1560.  
  1561.     bool bSuccess = false;
  1562.  
  1563.     i64 nFirstJump = (i64)pos - nJumpBackwards;
  1564.     ui64 nCurrentPos;
  1565.  
  1566.     if( nFirstJump<=0 )
  1567.         nFirstJump = 0;
  1568.  
  1569.   // Align stream to the pack header near the first Jump
  1570.     CDemux::SetStreamPos( CDemux::GetSyncPoint(pos) );
  1571.     
  1572.   m_bReadSuccess = true;
  1573.     // Read a PES of video
  1574.     while( m_bReadSuccess && (pos >= CDemux::GetStreamPos()) )
  1575.     {
  1576.         while( (m_bReadSuccess = ReadPES((unsigned char **)&m_pTempVideoBuffer, &dummyPes)) &&
  1577.             (dummyPes.streamID == streamID) )
  1578.         {
  1579.             // Wet got a video PES.
  1580.             // Get current Position
  1581.             nCurrentPos = CDemux::GetStreamPos();
  1582.             
  1583.             // Is the position requested inside our PES?
  1584.             if( pos <   nCurrentPos &&
  1585.                 pos >=  (nCurrentPos - dummyPes.payloadSize) )
  1586.             {
  1587.                 //Yep, it is.
  1588.                 m_nTempVideoBufferSize = dummyPes.payloadSize;
  1589.                 m_nTempVideoBufferPtr  = (ui32)(dummyPes.payloadSize - (nCurrentPos - pos));
  1590.                 m_nPesPosState = PesEnd;
  1591.                 bSuccess = true;
  1592.                 break;
  1593.             }
  1594.             else if( pos < nCurrentPos )
  1595.             {
  1596.                 // we missed the position requested without
  1597.                 // finding an appropiate PES position
  1598.                 DBG_STR((str, "VideoWrapper::SetStreamPos - Position not found\n"))
  1599.                 m_nTempVideoBufferSize = dummyPes.payloadSize;
  1600.                 m_nTempVideoBufferPtr = 0;
  1601.                 bSuccess = false;
  1602.                 break;
  1603.             }
  1604.         }
  1605.     }
  1606.  
  1607.   // Because this was a seek operation and we didnt succeed
  1608.   // remove the present data in the buffer because its no longer valid.
  1609.   if( !bSuccess )
  1610.     FlushBuffer();
  1611.  
  1612.     return bSuccess;
  1613. }
  1614.  
  1615. ui64 VideoWrapper::GetStreamPos()
  1616. {
  1617.     // Lock the decoder object in this function
  1618.     CAutoLock lock(&m_csLockSection);
  1619.  
  1620.     // Get real current position
  1621.     // If this Pes was read backwards the
  1622.     // end position was already retrieved
  1623.     ui64 nCurrentPos = m_nPesPosState==PesBegin ? m_nEndPesPosition : CDemux::GetStreamPos();
  1624.  
  1625.     return nCurrentPos - (m_nTempVideoBufferSize - m_nTempVideoBufferPtr );
  1626. }
  1627.     
  1628.  
  1629.  
  1630. int VideoWrapper::GetError()
  1631. {
  1632.     int temp;
  1633.     temp=error;
  1634.     error=0;
  1635.     return temp;
  1636. }
  1637.  
  1638. void VideoWrapper::updateVideoStats()
  1639. {
  1640.  
  1641.         if(isMPEG2)
  1642.     {
  1643.             DAR = MPEG2aspect_ratio_Table[aspect_ratio_information];
  1644.         }
  1645.         else{
  1646.             DAR = (MPEG1aspect_ratio_Table[aspect_ratio_information]*(double)pictureHeight)/((double)pictureWidth);
  1647.         }
  1648.         
  1649.         frameRate=frameRateTable[frame_rate_code];
  1650.         
  1651.         detectedFrameDelay=1/frameRateTable[detectedFrameRateCode];
  1652.  
  1653.         frameDelay=1/frameRate;
  1654.  
  1655. }
  1656.  
  1657. // Stub for feeding data to MSSG video decoder
  1658. bool VideoWrapper::ReadVideoData( ui8** ppBuffer, ui32* pBufferSize )
  1659. {
  1660.     if( m_nPesPosState == PesBegin )
  1661.         CDemux::SetStreamPos( m_nEndPesPosition );
  1662.     do{
  1663.         m_bReadSuccess = ReadLPES((unsigned char **)&m_pTempVideoBuffer, &myPES);
  1664.         if(!m_bReadSuccess) break;
  1665.         if( myPES.streamID    == subpic_streamID &&
  1666.             myPES.subStreamID == subpic_substreamID ) {
  1667.             /* this is a subpic; parse it, and discard it so the video decoder
  1668.             * doesn't see it */
  1669.             
  1670.             subpic_decode((unsigned char *)m_pTempVideoBuffer, myVideo->myPES.payloadSize, (int)((double)myVideo->myPES.PTS/27000.0) );
  1671.             continue;
  1672.         }
  1673.     }while( myPES.streamID!=streamID);
  1674.     
  1675.     // We are feeding the video decoder
  1676.     //   set the offset to what we've read.
  1677.     m_nTempVideoBufferSize   = myPES.payloadSize;
  1678.     m_nTempVideoBufferPtr    = myPES.payloadSize;
  1679.     m_nPesPosState = PesEnd;
  1680.     
  1681.     // Update buffers
  1682.     *ppBuffer     = m_pTempVideoBuffer;
  1683.     *pBufferSize = myPES.payloadSize;
  1684.     return m_bReadSuccess;
  1685. }
  1686.  
  1687. bool VideoWrapper::Is24Progressive()
  1688. {
  1689.   //This megamatic function will try to detect
  1690.   // the framerate of a stream, just looking into
  1691.   // the PTS from the incoming pictures.
  1692.   // This is necessary to detect 24 fps progressive sequences
  1693.   // that have the frame_rate set to 29.97 and use repeat_first_field flag
  1694.   //
  1695.   bool bSuccess = false;
  1696.  
  1697.   ui64 nStreamSize = GetStreamSize();
  1698.   // Jump to the middle
  1699.   CDemux::SetStreamPos(nStreamSize>>1);
  1700.     Initialize_Buffer();
  1701.   int nFramesToTry = 10;
  1702.   while( Get_Hdr() && nFramesToTry-- )
  1703.   {
  1704.     if(picture_structure!=FRAME_PICTURE)
  1705.       break;
  1706.     // If its not 29.97
  1707.     if( frame_rate_code!= 4 )
  1708.       break;
  1709.     if(repeat_first_field){
  1710.       bSuccess = true;
  1711.       break;
  1712.     }
  1713.   }
  1714.   return bSuccess;
  1715. }
  1716.  
  1717. bool VideoWrapper::BuildFrameDB()
  1718. {
  1719.   // Set stream to the beginning.
  1720.   SetStreamPos(0);
  1721.   bool bSuccess = true;
  1722.   ui8 byte;
  1723.   ui32 nTemporalReference;
  1724.  
  1725.   while(bSuccess)
  1726.   {
  1727.     // Find next startcode prefix
  1728.     ui32 nStartCode = 0xFFFFFF00;
  1729.     while( (nStartCode&0x00FFFFFF)!=1 && bSuccess )
  1730.     {
  1731.       bSuccess = GetFordByte(&byte);
  1732.       nStartCode = (nStartCode<<8) | byte;
  1733.     }
  1734.     GetFordByte(&byte);
  1735.     switch(byte)
  1736.     {
  1737.       case 0: // Picture start code
  1738.         // Get Start position
  1739.         m_sTempFrameInfo.nStartPos = GetStreamPos() - 4;
  1740.  
  1741.         
  1742.         GetFordByte(&byte);
  1743.         nTemporalReference = byte << 2;
  1744.         GetFordByte(&byte);
  1745.         nTemporalReference |= (byte&0xC0)>>6;
  1746.           
  1747.         // Get picture coding type
  1748.         m_sTempFrameInfo.picture_coding_type = (byte&0x3F)>>3;
  1749.         // If mpeg one, we're finished
  1750.         if(!isMPEG2)
  1751.           m_vFrames.push_back(m_sTempFrameInfo);
  1752.         break;
  1753.       case 0xB5: // extension start code
  1754.         GetFordByte(&byte);
  1755.         switch(byte>>4)
  1756.         {
  1757.         case 0x08: // picture extension
  1758.           GetFordByte(&byte);
  1759.           GetFordByte(&byte); // two last bits are picture_structure
  1760.           m_sTempFrameInfo.picture_structure = byte& 0x03;
  1761.           GetFordByte(&byte); // tff:8 bit    rff:2nd bit
  1762.           m_sTempFrameInfo.top_field_first    = byte & 0x80;
  1763.           m_sTempFrameInfo.repeat_first_field = byte & 0x02;
  1764.           GetFordByte(&byte); // progressive frame:8th bit
  1765.           m_sTempFrameInfo.progressive_frame  = byte & 0x80;
  1766.           break;
  1767.         }
  1768.           m_vFrames.push_back(m_sTempFrameInfo);
  1769.         break;
  1770.     }
  1771.   }
  1772.   int size = m_vFrames.size();
  1773.  
  1774.   return true;
  1775. }
  1776.  
  1777. TMPGVideoInfo * VideoWrapper::GetVideoInfo()
  1778. {
  1779.     video_info.width                    = Coded_Picture_Width;
  1780.     video_info.height                   = Coded_Picture_Height;
  1781.     video_info.aspect_ratio_information = aspect_ratio_information;
  1782.     video_info.bit_rate_value           = bit_rate_value;
  1783.     video_info.detected_frame_rate_code = detectedFrameRateCode;
  1784.     video_info.frame_rate_code          = frame_rate_code;
  1785.     video_info.isMPEG2                  = isMPEG2;
  1786.     video_info.progressive_frame        = progressive_frame;
  1787.     video_info.progressive_sequence     = progressive_sequence;
  1788.  
  1789.     return &video_info;
  1790. }
  1791.  
  1792.