You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
451 lines
9.8 KiB
451 lines
9.8 KiB
/*
|
|
* extract_pcm.c
|
|
*
|
|
* Copyright (C) Thomas Oestreich - June 2001
|
|
*
|
|
* This file is part of transcode, a video stream processing tool
|
|
*
|
|
* transcode 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.
|
|
*
|
|
* transcode 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, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
*/
|
|
|
|
#include "transcode.h"
|
|
#include "libtc/libtc.h"
|
|
#include "tcinfo.h"
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include "ioaux.h"
|
|
#include "avilib/wavlib.h"
|
|
#include "tc.h"
|
|
|
|
#define MAX_BUF 4096
|
|
char audio[MAX_BUF];
|
|
|
|
#define BUFFER_SIZE 262144
|
|
static uint8_t buffer[BUFFER_SIZE];
|
|
static FILE *in_file, *out_file;
|
|
|
|
static unsigned int track_code;
|
|
|
|
|
|
static void pes_lpcm_loop (void)
|
|
{
|
|
static int mpeg1_skip_table[16] = {
|
|
1, 0xffff, 5, 10, 0xffff, 0xffff, 0xffff, 0xffff,
|
|
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff
|
|
};
|
|
|
|
uint8_t * buf;
|
|
uint8_t * end;
|
|
uint8_t * tmp1=NULL;
|
|
uint8_t * tmp2=NULL;
|
|
int complain_loudly;
|
|
|
|
const unsigned *extract_order = 0;
|
|
unsigned extract_size = 0;
|
|
unsigned i;
|
|
unsigned left_over;
|
|
|
|
#ifdef WORDS_BIGENDIAN
|
|
static const unsigned lpcm_bebe16[4] = { 0,1, 2,3 };
|
|
static const unsigned lpcm_bebe24[12] = { 0,1,8, 2,3,9 ,4,5,10, 6,7,11 };
|
|
#else
|
|
static const unsigned lpcm_bele16[4] = { 1,0, 3,2 };
|
|
static const unsigned lpcm_bele24[12] = { 8,1,0, 9,3,2 ,10,5,4, 11,7,6 };
|
|
#endif
|
|
|
|
complain_loudly = 1;
|
|
buf = buffer;
|
|
left_over = 0;
|
|
|
|
do {
|
|
end = buf + fread (buf, 1, buffer + BUFFER_SIZE - buf, in_file);
|
|
buf = buffer;
|
|
|
|
//scan buffer
|
|
while (buf + 4 <= end) {
|
|
|
|
// check for valid start code
|
|
if (buf[0] || buf[1] || (buf[2] != 0x01)) {
|
|
if (complain_loudly && (verbose & TC_DEBUG)) {
|
|
tc_log_warn(__FILE__, "missing start code at %#lx",
|
|
ftell (in_file) - (end - buf));
|
|
if ((buf[0] == 0) && (buf[1] == 0) && (buf[2] == 0))
|
|
tc_log_warn(__FILE__, "incorrect zero-byte padding detected - ignored");
|
|
complain_loudly = 0;
|
|
}
|
|
buf++;
|
|
continue;
|
|
}// check for valid start code
|
|
|
|
if(verbose & TC_STATS)
|
|
tc_log_msg(__FILE__, "packet code 0x%x", buf[3]);
|
|
|
|
switch (buf[3]) {
|
|
|
|
case 0xb9: /* program end code */
|
|
return;
|
|
|
|
case 0xba: /* pack header */
|
|
|
|
/* skip */
|
|
if ((buf[4] & 0xc0) == 0x40) /* mpeg2 */
|
|
tmp1 = buf + 14 + (buf[13] & 7);
|
|
else if ((buf[4] & 0xf0) == 0x20) /* mpeg1 */
|
|
tmp1 = buf + 12;
|
|
else if (buf + 5 > end)
|
|
goto copy;
|
|
else {
|
|
tc_log_error(__FILE__, "weird pack header");
|
|
import_exit(1);
|
|
}
|
|
|
|
if (tmp1 > end)
|
|
goto copy;
|
|
buf = tmp1;
|
|
break;
|
|
|
|
|
|
case 0xbd: /* private stream 1 */
|
|
tmp2 = buf + 6 + (buf[4] << 8) + buf[5];
|
|
if (tmp2 > end)
|
|
goto copy;
|
|
if ((buf[6] & 0xc0) == 0x80) /* mpeg2 */
|
|
tmp1 = buf + 9 + buf[8];
|
|
else { /* mpeg1 */
|
|
for (tmp1 = buf + 6; *tmp1 == 0xff; tmp1++)
|
|
if (tmp1 == buf + 6 + 16) {
|
|
tc_log_warn(__FILE__, "too much stuffing");
|
|
buf = tmp2;
|
|
break;
|
|
}
|
|
if ((*tmp1 & 0xc0) == 0x40)
|
|
tmp1 += 2;
|
|
tmp1 += mpeg1_skip_table [*tmp1 >> 4];
|
|
}
|
|
|
|
if(verbose & TC_STATS)
|
|
tc_log_msg(__FILE__, "track code 0x%x", *tmp1);
|
|
|
|
if (*tmp1 == track_code) {
|
|
|
|
tmp1++;
|
|
|
|
/*
|
|
* Additional audio header consists of:
|
|
* number of frames
|
|
* offset to frame start (high byte)
|
|
* offset to frame start (low byte)
|
|
*
|
|
* followed by LPCM header:
|
|
* emphasis:1, mute:1, rvd:1, frame number:5
|
|
* quantization:2, freq:2, rvd:1, channels:3
|
|
* dynamic range control (0x80=off)
|
|
*/
|
|
|
|
tmp1 += 3;
|
|
|
|
switch ((tmp1[1] >> 6) & 3) {
|
|
case 0: extract_size = 4;
|
|
#ifdef WORDS_BIGENDIAN
|
|
extract_order = lpcm_bebe16;
|
|
#else
|
|
extract_order = lpcm_bele16;
|
|
#endif
|
|
break;
|
|
case 2: extract_size = 12;
|
|
#ifdef WORDS_BIGENDIAN
|
|
extract_order = lpcm_bebe24;
|
|
#else
|
|
extract_order = lpcm_bele24;
|
|
#endif
|
|
break;
|
|
default: tc_log_error(__FILE__, "unsupported LPCM quantization");
|
|
import_exit (1);
|
|
}
|
|
|
|
tmp1 += 3;
|
|
|
|
if (left_over) {
|
|
while (left_over < extract_size && tmp1 != tmp2)
|
|
audio[left_over++] = *tmp1++;
|
|
if (left_over == extract_size) {
|
|
for (i = 0; i < extract_size; i++)
|
|
fputc (audio[extract_order[i]], out_file);
|
|
left_over = 0;
|
|
}
|
|
}
|
|
|
|
while ((tmp2 - tmp1) >= extract_size) {
|
|
for (i = 0; i < extract_size; i++)
|
|
fputc (tmp1[extract_order[i]], out_file);
|
|
tmp1 += extract_size;
|
|
}
|
|
|
|
while (tmp1 != tmp2)
|
|
audio[left_over++] = *tmp1++;
|
|
}
|
|
|
|
buf = tmp2;
|
|
break;
|
|
|
|
default:
|
|
if (buf[3] < 0xb9) {
|
|
tc_log_error(__FILE__, "looks like a video stream, not program stream");
|
|
import_exit(1);
|
|
}
|
|
|
|
/* skip */
|
|
tmp1 = buf + 6 + (buf[4] << 8) + buf[5];
|
|
if (tmp1 > end)
|
|
goto copy;
|
|
buf = tmp1;
|
|
break;
|
|
|
|
} //start code selection
|
|
} //scan buffer
|
|
|
|
if (buf < end) {
|
|
copy:
|
|
/* we only pass here for mpeg1 ps streams */
|
|
memmove (buffer, buf, end - buf);
|
|
}
|
|
buf = buffer + (end - buf);
|
|
|
|
} while (end == buffer + BUFFER_SIZE);
|
|
}
|
|
|
|
|
|
extern void import_exit(int ret);
|
|
|
|
/* ------------------------------------------------------------
|
|
*
|
|
* pcm extract thread
|
|
*
|
|
* magic: TC_MAGIC_AVI
|
|
* TC_MAGIC_RAW <-- default
|
|
* TC_MAGIC_WAW
|
|
* TC_MAGIC_VOB
|
|
*
|
|
* ------------------------------------------------------------*/
|
|
|
|
|
|
void extract_pcm(info_t *ipipe)
|
|
{
|
|
|
|
avi_t *avifile;
|
|
|
|
unsigned long frames, bytes, padding, n;
|
|
|
|
int error=0;
|
|
|
|
WAV wav = NULL;
|
|
|
|
|
|
/* ------------------------------------------------------------
|
|
*
|
|
* AVI
|
|
*
|
|
* ------------------------------------------------------------*/
|
|
|
|
// AVI
|
|
|
|
switch (ipipe->magic) {
|
|
|
|
case TC_MAGIC_AVI:
|
|
|
|
if(ipipe->stype == TC_STYPE_STDIN){
|
|
tc_log_error(__FILE__, "invalid magic/stype - exit");
|
|
error=1;
|
|
break;
|
|
}
|
|
|
|
// scan file
|
|
if (ipipe->nav_seek_file) {
|
|
if(NULL == (avifile = AVI_open_indexfd(ipipe->fd_in,0,ipipe->nav_seek_file))) {
|
|
AVI_print_error("AVI open");
|
|
break;
|
|
}
|
|
} else {
|
|
if(NULL == (avifile = AVI_open_fd(ipipe->fd_in,1))) {
|
|
AVI_print_error("AVI open");
|
|
break;
|
|
}
|
|
}
|
|
|
|
//set selected for multi-audio AVI-files
|
|
AVI_set_audio_track(avifile, ipipe->track);
|
|
|
|
// get total audio size
|
|
bytes=ipipe->frame_limit[1] - ipipe->frame_limit[0];
|
|
if (ipipe->frame_limit[1] ==LONG_MAX)
|
|
{
|
|
bytes = AVI_audio_bytes(avifile);
|
|
}
|
|
AVI_set_audio_position(avifile,ipipe->frame_limit[0]);
|
|
|
|
padding = bytes % MAX_BUF;
|
|
frames = bytes / MAX_BUF;
|
|
for (n=0; n<frames; ++n) {
|
|
|
|
if(AVI_read_audio(avifile, audio, MAX_BUF)<0) {
|
|
error=1;
|
|
break;
|
|
}
|
|
|
|
if(tc_pwrite(ipipe->fd_out, audio, MAX_BUF)!= MAX_BUF) {
|
|
error=1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if((bytes = AVI_read_audio(avifile, audio, padding)) < padding)
|
|
error=1;
|
|
|
|
if(tc_pwrite(ipipe->fd_out, audio, bytes)!= bytes) error=1;
|
|
|
|
break;
|
|
|
|
/* ------------------------------------------------------------
|
|
*
|
|
* WAV
|
|
*
|
|
* ------------------------------------------------------------*/
|
|
|
|
// WAV
|
|
|
|
case TC_MAGIC_WAV:
|
|
|
|
wav = wav_fdopen(ipipe->fd_in, WAV_READ|WAV_PIPE, NULL);
|
|
if (wav == NULL) {
|
|
error=1;
|
|
break;
|
|
}
|
|
|
|
do {
|
|
bytes = wav_read_data(wav, audio, MAX_BUF);
|
|
if(bytes != MAX_BUF) error=1;
|
|
if(tc_pwrite(ipipe->fd_out, audio, bytes)!= bytes) error=1;
|
|
} while(!error);
|
|
|
|
wav_close(wav);
|
|
|
|
break;
|
|
|
|
/* ------------------------------------------------------------
|
|
*
|
|
* VOB
|
|
*
|
|
* ------------------------------------------------------------*/
|
|
|
|
// VOB
|
|
|
|
case TC_MAGIC_VOB:
|
|
|
|
in_file = fdopen(ipipe->fd_in, "r");
|
|
out_file = fdopen(ipipe->fd_out, "w");
|
|
|
|
track_code = 0xA0 + ipipe->track;
|
|
pes_lpcm_loop();
|
|
|
|
fclose(in_file);
|
|
fclose(out_file);
|
|
|
|
break;
|
|
|
|
|
|
/* ------------------------------------------------------------
|
|
*
|
|
* RAW
|
|
*
|
|
* ------------------------------------------------------------*/
|
|
|
|
// RAW
|
|
|
|
case TC_MAGIC_RAW:
|
|
|
|
default:
|
|
|
|
if(ipipe->magic == TC_MAGIC_UNKNOWN)
|
|
tc_log_warn(__FILE__, "no file type specified, assuming %s",
|
|
filetype(TC_MAGIC_RAW));
|
|
|
|
bytes=ipipe->frame_limit[1] - ipipe->frame_limit[0];
|
|
//skip the first ipipe->frame_limit[0] bytes
|
|
if (ipipe->frame_limit[0]!=0)
|
|
if (lseek(ipipe->fd_in,ipipe->frame_limit[0],SEEK_SET) !=0)
|
|
{
|
|
error=1;
|
|
break;
|
|
}
|
|
if (ipipe->frame_limit[1] ==LONG_MAX)
|
|
{
|
|
error=tc_preadwrite(ipipe->fd_in, ipipe->fd_out);
|
|
}
|
|
else
|
|
{
|
|
padding = bytes % MAX_BUF;
|
|
frames = bytes / MAX_BUF;
|
|
for (n=0; n<frames; ++n)
|
|
{
|
|
if(tc_pread(ipipe->fd_in, audio, MAX_BUF)!= MAX_BUF)
|
|
{
|
|
error=1;
|
|
break;
|
|
}
|
|
if(tc_pwrite(ipipe->fd_out, audio, MAX_BUF)!= MAX_BUF)
|
|
{
|
|
error=1;
|
|
break;
|
|
}
|
|
}
|
|
if (padding !=0)
|
|
{
|
|
if(tc_pread(ipipe->fd_in, audio, padding)!= padding)
|
|
{
|
|
error=1;
|
|
break;
|
|
}
|
|
if(tc_pwrite(ipipe->fd_out, audio, padding)!= padding)
|
|
{
|
|
error=1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if(error) {
|
|
tc_log_perror(__FILE__, "error while writing data");
|
|
import_exit(error);
|
|
}
|
|
}
|
|
|
|
/*************************************************************************/
|
|
|
|
/*
|
|
* Local variables:
|
|
* c-file-style: "stroustrup"
|
|
* c-file-offsets: ((case-label . *) (statement-case-intro . *))
|
|
* indent-tabs-mode: nil
|
|
* End:
|
|
*
|
|
* vim: expandtab shiftwidth=4:
|
|
*/
|