Logo Search packages:      
Sourcecode: alsa-tools version File versions  Download package

extract_ac3.c

/*
 *  extract_ac3.c
 *
 *  Copyright (C) Aaron Holtzman <aholtzma@ess.engr.uvic.ca> - June 1999
 *
 *  Extracts an AC-3 audio stream from an MPEG-2 system stream
 *  and writes it to stdout
 *
 *  Ideas and bitstream syntax info borrowed from code written 
 *  by Nathan Laredo <laredo@gnu.org>
 *
 *  Multiple track support by Yuqing Deng <deng@tinker.chem.brown.edu>
 * 
 *
 *  This file is part of ac3dec, a free Dolby AC-3 stream decoder.
 *    
 *  ac3dec is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *   
 *  ac3dec is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *   
 *  You should have received a copy of the GNU General Public License
 *  along with GNU Make; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/mman.h>


/* Audio track to play */
static unsigned char track_code = 0x80;
static unsigned char track_table[8] = 
{ 
      0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87 
};

#define BUFSIZE 512 /* needs to be as big as biggest header */
static int vobf;
static unsigned char buf[BUFSIZE];
static unsigned char *cur_pos;
static unsigned char *end_pos;

void file_init(char file_name[])
{
      if(file_name[0] == '-' && file_name[1] == '\0')
      {
         vobf = STDIN_FILENO;
      }
      else if ((vobf = open(file_name, O_RDONLY)) < 0)
      {
            fprintf(stderr,"File not found\n");
            exit(1);
      }
      cur_pos = buf;
      end_pos = buf;
}

inline void increment_position(long x)
{
      if(cur_pos + x <= end_pos)
      {
         cur_pos += x;
         if(cur_pos == end_pos)
         {
            cur_pos = buf;
                end_pos = buf;
         }
      }
      else
      {
           long size = 0;
           x -= (long)(end_pos - cur_pos);
#ifdef SEEK_PIPES
            if(lseek(vobf, x, SEEK_CUR) < 0)
            {
               fprintf(stderr, "Error: unexpected end of stream\n");
               exit(1);
            }
#else
            while(x)
            {
               size = (x > BUFSIZE) ? BUFSIZE : x;
               if(read(vobf, buf, size) < size)
               {
                  fprintf(stderr, "Error: unexpected end of stream\n");
                  exit(1);
               }
                   x-=size;
            }
#endif
            cur_pos = buf;
                end_pos = buf;
      }
}

inline static void load_next_bytes(long count)
{
   if(cur_pos + count <= end_pos)
      return;
   if(cur_pos + count > buf + BUFSIZE - 1 )
   {
      printf ("No buffer space to read %ld bytes\n", count);
      exit(1);
   }

   count -= (long)(end_pos - cur_pos);
   if(read(vobf, end_pos, count) < count)
   {
      fprintf(stderr, "Error: unexpected end of stream\n");
      exit(1);
   }
   end_pos += count;
}

inline int next_24_bits(long x)
{
   load_next_bytes(3);
      if (cur_pos[0] != ((x >> 16) & 0xff))
            return 0;
      if (cur_pos[1] != ((x >>  8) & 0xff))
            return 0;
      if (cur_pos[2] != ((x      ) & 0xff))
            return 0;

      return 1;
}

inline int next_32_bits(long x)
{
   load_next_bytes(4);
      if (cur_pos[0] != ((x >> 24) & 0xff))
            return 0;
      if (cur_pos[1] != ((x >> 16) & 0xff))
            return 0;
      if (cur_pos[2] != ((x >>  8) & 0xff))
            return 0;
      if (cur_pos[3] != ((x      ) & 0xff))
            return 0;

      return 1;
}

void read_write_next_bytes(long count, int outfd)
{
   long size;
   size = (long)(end_pos - cur_pos);
   if(size > count)
   {
      write(outfd, cur_pos, count);
      cur_pos +=count;
      if(cur_pos == end_pos)
      {
       cur_pos = buf;
       end_pos = buf;
      }
      return;
   }
   else if(size > 0)
   {
      write(outfd, cur_pos, size);
   }

   while(count)
   {
      size = (count > BUFSIZE) ? BUFSIZE : count;
      if(read(vobf, buf, size) < size ||
       write(outfd, buf, size) < size)
      {
       fprintf(stderr, "Error: unexpected end of stream\n");
      }
      count -= size;
   }
   cur_pos = buf;
   end_pos = buf;
}

void parse_pes(void)
{
      unsigned long data_length;
      unsigned long header_length;

      load_next_bytes(9);

      //The header length is the PES_header_data_length byte plus 6 for the packet
      //start code and packet size, 3 for the PES_header_data_length and two
      //misc bytes, and finally 4 bytes for the mystery AC3 packet tag 
      header_length = cur_pos[8] + 6 + 3 + 4 ;
      data_length =(cur_pos[4]<<8) + cur_pos[5];


      //If we have AC-3 audio then output it
      if(cur_pos[3] == 0xbd)
      {
            load_next_bytes(header_length);
#if 0
            //Debugging printfs
            fprintf(stderr,"start of pes curpos[] = %02x%02x%02x%02x\n",
                  cur_pos[0],cur_pos[1],cur_pos[2],cur_pos[3]);
            fprintf(stderr,"header_length = %d data_length = %x\n",
                  header_length, data_length);
            fprintf(stderr,"extra crap 0x%02x%02x%02x%02x data size 0x%0lx\n",cur_pos[header_length-4],
                  cur_pos[header_length-3],cur_pos[header_length-2],cur_pos[header_length-1],data_length);
#endif

            //Only extract the track we want
            if((cur_pos[header_length-4] == track_code )) 
            {
               increment_position(header_length);
                  read_write_next_bytes(data_length - header_length + 6, STDOUT_FILENO);

            }
            else
            {
             increment_position(data_length + 6);
            }
      }
      else
      {
         //The packet size is data_length plus 6 bytes to account for the
         //packet start code and the data_length itself.
         increment_position(data_length + 6);
      }
}

void parse_pack(void)
{
      unsigned long skip_length;

      // Deal with the pack header 
      // The first 13 bytes are junk. The fourteenth byte 
      // contains the number of stuff bytes 
      load_next_bytes(14);
      skip_length = cur_pos[13] & 0x7;
      increment_position(14 + skip_length);

      // Deal with the system header if it exists 
      if(next_32_bits(0x000001bb))
      {
      // Bytes 5 and 6 contain the length of the header minus 6
                load_next_bytes(6);
            skip_length = (cur_pos[4] << 8) +  cur_pos[5];
            increment_position(6 + skip_length);
      }

      while(next_24_bits(0x000001) && !next_32_bits(0x000001ba))
      {
            parse_pes();
      }
}

int main(int argc, char *argv[])
{
      int track = 0;

      if (argc < 2) {
            fprintf(stderr, "usage: %s mpeg_stream [track number]\n", argv[0]);
            exit(1);
      }

      if (argc == 3) 
      {
            track = strtol(argv[2], NULL, 0);
            fprintf(stderr,"Extracting track %d\n",track);
      }

      if (track < 0 || track > 7) 
      {
            fprintf(stderr, "Invalid track number: %d\n", track);
            exit(1);
      }

      track_code = track_table[track];



      file_init(argv[1]);

      if(!next_32_bits(0x000001ba))
      {
            fprintf(stderr, "Non-program streams not handled - exiting\n\n");
            exit(1);
      }

      do
      {
            parse_pack();
      } 
      while(next_32_bits(0x000001ba));

      fprintf(stderr,"curpos[] = %x%x%x%x\n",cur_pos[0],cur_pos[1],cur_pos[2],cur_pos[3]);

      if(!next_32_bits(0x000001b9))
      {
            fprintf(stderr, "Error: expected end of stream code\n");
            exit(1);
      }

      if(vobf != STDIN_FILENO) close(vobf);
      return 0;
}           

Generated by  Doxygen 1.6.0   Back to index