git.sesse.net Git - vlc/blob - modules/demux/mkv/Ebml_parser.cpp

   1
   2 /*****************************************************************************
   3  * EbmlParser for the matroska demuxer
   4  *****************************************************************************
   5  * Copyright (C) 2003-2004 VLC authors and VideoLAN
   6  * $Id$
   7  *
   8  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   9  *          Steve Lhomme <steve.lhomme@free.fr>
  10  *
  11  * This program is free software; you can redistribute it and/or modify it
  12  * under the terms of the GNU Lesser General Public License as published by
  13  * the Free Software Foundation; either version 2.1 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19  * GNU Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * along with this program; if not, write to the Free Software Foundation,
  23  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 #include "Ebml_parser.hpp"
  27 #include "stream_io_callback.hpp"
  28
  29 /*****************************************************************************
  30  * Ebml Stream parser
  31  *****************************************************************************/
  32 EbmlParser::EbmlParser( EbmlStream *es, EbmlElement *el_start, demux_t *p_demux ) :
  33     p_demux( p_demux ),
  34     m_es( es ),
  35     mi_level( 1 ),
  36     m_got( NULL ),
  37     mi_user_level( 1 ),
  38     mb_keep( false )
  39 {
  40     mi_remain_size[0] = el_start->GetSize();
  41     memset( m_el, 0, 6 * sizeof( *m_el ) );
  42     m_el[0] = el_start;
  43     mb_dummy = var_InheritBool( p_demux, "mkv-use-dummy" );
  44 }
  45
  46 EbmlParser::~EbmlParser( void )
  47 {
  48     if( !mi_level )
  49     {
  50         assert( !mb_keep );
  51         delete m_el[1];
  52         return;
  53     }
  54
  55     for( int i = 1; i <= mi_level; i++ )
  56     {
  57         if( !mb_keep )
  58         {
  59             delete m_el[i];
  60         }
  61         mb_keep = false;
  62     }
  63 }
  64
  65 EbmlElement* EbmlParser::UnGet( uint64 i_block_pos, uint64 i_cluster_pos )
  66 {
  67     if ( mi_user_level > mi_level )
  68     {
  69         while ( mi_user_level != mi_level )
  70         {
  71             delete m_el[mi_user_level];
  72             m_el[mi_user_level] = NULL;
  73             mi_user_level--;
  74         }
  75     }
  76
  77     /* Avoid data skip in BlockGet */
  78     delete m_el[mi_level];
  79     m_el[mi_level] = NULL;
  80
  81     m_got = NULL;
  82     mb_keep = false;
  83     if ( m_el[1] && m_el[1]->GetElementPosition() == i_cluster_pos )
  84     {
  85         m_es->I_O().setFilePointer( i_block_pos, seek_beginning );
  86         return m_el[1];
  87     }
  88     else
  89     {
  90         // seek to the previous Cluster
  91         m_es->I_O().setFilePointer( i_cluster_pos, seek_beginning );
  92         while(mi_level > 1)
  93         {
  94             mi_level--;
  95             mi_user_level--;
  96             delete m_el[mi_level];
  97             m_el[mi_level] = NULL;
  98         }
  99         return NULL;
 100     }
 101 }
 102
 103 void EbmlParser::Up( void )
 104 {
 105     if( mi_user_level == mi_level )
 106     {
 107         msg_Warn( p_demux, "MKV/Ebml Parser: Up cannot escape itself" );
 108     }
 109
 110     mi_user_level--;
 111 }
 112
 113 void EbmlParser::Down( void )
 114 {
 115     mi_user_level++;
 116     mi_level++;
 117 }
 118
 119 void EbmlParser::Keep( void )
 120 {
 121     mb_keep = true;
 122 }
 123
 124 int EbmlParser::GetLevel( void ) const
 125 {
 126     return mi_user_level;
 127 }
 128
 129 void EbmlParser::Reset( demux_t *p_demux )
 130 {
 131     while ( mi_level > 0)
 132     {
 133         delete m_el[mi_level];
 134         m_el[mi_level] = NULL;
 135         mi_level--;
 136     }
 137     this->p_demux = p_demux;
 138     mi_user_level = mi_level = 1;
 139     // a little faster and cleaner
 140     m_es->I_O().setFilePointer( static_cast<KaxSegment*>(m_el[0])->GetGlobalPosition(0) );
 141     mb_dummy = var_InheritBool( p_demux, "mkv-use-dummy" );
 142 }
 143
 144 EbmlElement *EbmlParser::Get( int n_call )
 145 {
 146     int i_ulev = 0;
 147     EbmlElement *p_prev = NULL;
 148
 149     if( mi_user_level != mi_level )
 150     {
 151         return NULL;
 152     }
 153     if( m_got )
 154     {
 155         EbmlElement *ret = m_got;
 156         m_got = NULL;
 157
 158         return ret;
 159     }
 160
 161     p_prev = m_el[mi_level];
 162     if( m_el[mi_level] )
 163     {
 164         m_el[mi_level]->SkipData( *m_es, EBML_CONTEXT(m_el[mi_level]) );
 165
 166     }
 167     vlc_stream_io_callback & io_stream = (vlc_stream_io_callback &) m_es->I_O();
 168     uint64 i_size = io_stream.toRead();
 169     m_el[mi_level] = m_es->FindNextElement( EBML_CONTEXT(m_el[mi_level - 1]),
 170                                             i_ulev, i_size, true, 1 );
 171 //    mi_remain_size[mi_level] = m_el[mi_level]->GetSize();
 172     if( i_ulev > 0 )
 173     {
 174         if( p_prev )
 175         {
 176             if( !mb_keep )
 177             {
 178                 if( MKV_IS_ID( p_prev, KaxBlockVirtual ) )
 179                     static_cast<KaxBlockVirtualWorkaround*>(p_prev)->Fix();
 180                 delete p_prev;
 181             }
 182             mb_keep = false;
 183         }
 184         while( i_ulev > 0 )
 185         {
 186             if( mi_level == 1 )
 187             {
 188                 mi_level = 0;
 189                 return NULL;
 190             }
 191
 192             delete m_el[mi_level - 1];
 193             m_got = m_el[mi_level -1] = m_el[mi_level];
 194             m_el[mi_level] = NULL;
 195
 196             mi_level--;
 197             i_ulev--;
 198         }
 199         return NULL;
 200     }
 201     else if( m_el[mi_level] == NULL )
 202     {
 203         msg_Warn( p_demux,"MKV/Ebml Parser: m_el[mi_level] == NULL\n" );
 204     }
 205     else if( m_el[mi_level]->IsDummy() && !mb_dummy )
 206     {
 207         bool b_bad_position = false;
 208         /* We got a dummy element but don't want those...
 209          * perform a sanity check */
 210         if( !mi_level )
 211         {
 212             msg_Err(p_demux, "Got invalid lvl 0 element... Aborting");
 213             return NULL;
 214         }
 215
 216         if( p_prev && p_prev->IsFiniteSize() &&
 217             p_prev->GetEndPosition() != m_el[mi_level]->GetElementPosition())
 218         {
 219             msg_Err( p_demux, "Dummy Element at unexpected position... corrupted file?" );
 220             b_bad_position = true;
 221         }
 222
 223         if( n_call < 10 && !b_bad_position && m_el[mi_level]->IsFiniteSize() &&
 224             ( !m_el[mi_level-1]->IsFiniteSize() ||
 225               m_el[mi_level]->GetEndPosition() <= m_el[mi_level-1]->GetEndPosition() ) )
 226         {
 227             /* The element fits inside its upper element */
 228             msg_Warn( p_demux, "Dummy element found... skipping it" );
 229             return Get( ++n_call );
 230         }
 231         else
 232         {
 233             /* Too large, misplaced or 10 successive dummy elements */
 234             msg_Err( p_demux, "Dummy element too large or misplaced... skipping to next upper element" );
 235             delete m_el[mi_level];
 236             m_el[mi_level] = NULL;
 237             m_el[mi_level - 1]->SkipData( *m_es, EBML_CONTEXT(m_el[mi_level - 1]) );
 238             return Get();
 239         }
 240     }
 241
 242     if( p_prev )
 243     {
 244         if( !mb_keep )
 245         {
 246             if( MKV_IS_ID( p_prev, KaxBlockVirtual ) )
 247                 static_cast<KaxBlockVirtualWorkaround*>(p_prev)->Fix();
 248             delete p_prev;
 249         }
 250         mb_keep = false;
 251     }
 252     return m_el[mi_level];
 253 }
 254
 255 bool EbmlParser::IsTopPresent( EbmlElement *el ) const
 256 {
 257     for( int i = 0; i < mi_level; i++ )
 258     {
 259         if( m_el[i] && m_el[i] == el )
 260             return true;
 261     }
 262     return false;
 263 }
 264