Задержка кадров анимации gif

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <cstdlib>
#include <cstring>
#include <cstdint>
#include <cmath>
#include <vector>
#include <sstream>
#include <stdexcept>
 
using namespace std;
 
namespace
{
   const uint8_t extension_introducer = 0x21 ;
   const uint8_t graphic_control_label = 0xF9 ;
   const uint8_t block_terminate = 0x00 ;
   const uint8_t comment_label = 0xFE ;
   const uint8_t plain_text_label = 0x01 ;
   const uint8_t extension_label = 0xFF ;
   const uint8_t gif_trailer = 0x3B ;
   const uint8_t image_separator = 0x2C ;
}
 
uint16_t delay = 0 ;
 
 
inline char * uint8_to_pchar ( uint8_t * p )
{
   return reinterpret_cast<char*>(p) ;
}
 
 
size_t read_bytes ( std::istream & stream , std::vector<uint8_t> & buffer , size_t read_bytes_count )
{
   buffer.resize(read_bytes_count) ;
   stream.read( uint8_to_pchar(buffer.data()) , read_bytes_count ) ;
   size_t gcount = stream.gcount() ;
   buffer.resize(gcount) ;
   if ( gcount != read_bytes_count )
      throw std::runtime_error ("read file error in [" + std::to_string(stream.tellg()) + "] position") ;
   return gcount ;
}
 
void write_bytes ( std::ostream & stream , std::vector<uint8_t> & buffer  )
{
   stream.write( uint8_to_pchar(buffer.data()) , buffer.size() ) ;
   if ( !stream.good() )
      throw std::runtime_error ("write file error") ;
}
 
 
uint8_t read_extension_introducer ( std::istream & stream , std::vector<uint8_t> & buffer )
{
   std::vector<uint8_t> temp_buffer(255) ;
   read_bytes ( stream , temp_buffer , 1 ) ;
   buffer.insert(buffer.end(),temp_buffer.begin(),temp_buffer.end()) ;
   uint8_t type_block = temp_buffer[0] ;
   switch ( type_block )
   {
      case graphic_control_label :
      {
         read_bytes(stream,temp_buffer,6) ;
         if ( temp_buffer[0] != 4 )
            throw std::runtime_error ( "error: block size failure in graphic_control_label" ) ;
         if ( temp_buffer[5] != block_terminate )
            throw std::runtime_error ( "error: block_terminate failure" ) ;
 
         uint16_t & delay_frame = *reinterpret_cast<uint16_t*>(temp_buffer.data()+2) ;
         delay_frame = delay ; //Задержка
 
         break ;
      }
      case comment_label :
      {
         while ( !stream.eof() )
         {
            read_bytes(stream,temp_buffer,1) ;
            if ( temp_buffer[0]==block_terminate )
               break ;
            buffer.push_back(temp_buffer[0]) ;
         }
         break ;
      }
      case plain_text_label :
      {
         read_bytes(stream,temp_buffer,13) ;
         buffer.insert(buffer.end(),temp_buffer.begin(),temp_buffer.end()) ;
         if ( temp_buffer[0] != 12 )
            throw std::runtime_error ( "error: block size failure in plain_text_label" ) ;
         while ( !stream.eof() )
         {
            read_bytes(stream,temp_buffer,1) ;
            if ( temp_buffer[0]==block_terminate )
               break ;
            buffer.push_back(temp_buffer[0]) ;
         }
         break ;
      }
      case extension_label :
      {
         read_bytes(stream,temp_buffer,12) ;
         buffer.insert(buffer.end(),temp_buffer.begin(),temp_buffer.end()) ;
         if ( temp_buffer[0] != 11 )
            throw std::runtime_error ( "error: block size failure in extension_label" ) ;
         while ( !stream.eof() )
         {
            read_bytes(stream,temp_buffer,1) ;
            if ( temp_buffer[0]==block_terminate )
               break ;
            buffer.push_back(temp_buffer[0]) ;
         }
         break ;
      }
      default:
         throw std::runtime_error ( "error: unknown block" ) ;
   }
   buffer.insert(buffer.end(),temp_buffer.begin(),temp_buffer.end()) ;
   return type_block ;
}
 
void read_image_descriptor ( std::istream & stream , std::vector<uint8_t> & buffer )
{
   std::vector<uint8_t> temp_buffer(9) ;
   read_bytes(stream,temp_buffer,9) ;
   buffer.insert(buffer.end(),temp_buffer.begin(),temp_buffer.end()) ;
}
 
void read_raster_data ( std::istream & stream , std::vector<uint8_t> & buffer )
{
   std::vector<uint8_t> temp_buffer(1024) ;
   read_bytes(stream,temp_buffer,1) ;
   buffer.insert(buffer.end(),temp_buffer.begin(),temp_buffer.end()) ;
   while ( true )
   {
      read_bytes(stream,temp_buffer,1) ;
      uint8_t block_size = temp_buffer[0] ;
      buffer.insert(buffer.end(),temp_buffer.begin(),temp_buffer.end()) ;
      if ( block_size == block_terminate )
         break ;
      read_bytes(stream,temp_buffer,block_size) ;
      buffer.insert(buffer.end(),temp_buffer.begin(),temp_buffer.end()) ;
   }
}
 
int main( int argc , char * argv[] )
{
   if ( argc < 4 )
   {
      std::cerr << "command: source_file_path destinate_file path delay_time" ;
      return EXIT_FAILURE ;
   }
 
   std::stringstream ss(argv[3]) ;
   ss >> delay ;
 
   std::string in_path (argv[1]) ;
   std::string out_path (argv[2]) ;
   std::ifstream in_file ( in_path , std::ios::binary ) ;
   std::ofstream out_file ( out_path , std::ios::binary ) ;
 
   if ( !in_file.is_open() )
   {
      std::cerr << "Error: can not open file " << in_path << std::endl ;
      return EXIT_FAILURE ;
   }
   if ( !out_file.is_open() )
   {
      std::cerr << "Error: can not open file " << out_path << std::endl ;
      return EXIT_FAILURE ;
   }
   std::vector<uint8_t> result_buffer ;
   std::vector<uint8_t> buffer(255) ;
   try
   {
      read_bytes(in_file,buffer,13) ;
      result_buffer.insert(result_buffer.end(),buffer.begin(),buffer.end()) ;
      if ( memcmp(buffer.data(),"GIF89a",6) )
      {
         std::cerr << "Error: GIF Data Stream is not GIF89a" << std::endl ;
         return EXIT_FAILURE ;
      }
 
      bool global_color_table_flag = buffer[10] & 1<<(sizeof(uint8_t)-1) ;
 
 
 
      if ( global_color_table_flag )
      {
         uint8_t size_of_global_color_table = buffer[10] & 0x7 ;
         size_t global_color_table_bytes = 3 * pow(2,size_of_global_color_table+1) ;
         read_bytes(in_file,buffer,global_color_table_bytes) ;
         result_buffer.insert(result_buffer.end(),buffer.begin(),buffer.end()) ;
      }
      bool reading = true ;
      while ( reading )
      {
         read_bytes(in_file,buffer,1 ) ;
         uint8_t type = buffer[0] ;
         result_buffer.insert(result_buffer.end(),buffer.begin(),buffer.end()) ;
         buffer.clear() ;
         switch (type)
         {
            case extension_introducer :
            {
               read_extension_introducer(in_file,buffer) ;
               break ;
            }
            case image_separator :
            {
               read_image_descriptor(in_file,buffer) ;
               result_buffer.insert(result_buffer.end(),buffer.begin(),buffer.end()) ;
               if ( buffer.back() & (1<<(sizeof(uint8_t)-1)) )
               {
                  read_bytes(in_file,buffer,3*pow(2,(buffer.back()&0x7)+1)) ;
                  result_buffer.insert(result_buffer.end(),buffer.begin(),buffer.end()) ;
               }
               buffer.clear() ;
               read_raster_data(in_file,buffer) ;
               result_buffer.insert(result_buffer.end(),buffer.begin(),buffer.end()) ;
               buffer.clear() ;
               break ;
            }
            case gif_trailer :
               std::cout<<"Reading end"<<std::endl ;
               reading = false ;
               break ;
         }
         result_buffer.insert(result_buffer.end(),buffer.begin(),buffer.end()) ;
      }
 
 
 
      write_bytes (out_file,result_buffer ) ;
   } catch ( const std::runtime_error & e )
   {
      std::cerr << e.what() << std::endl ;
   }
}

delay_frame = delay ; //Задержка