void
avi_reader_c::set_avc_nal_size_size(mpeg4_p10_es_video_packetizer_c *ptzr) {
m_avc_nal_size_size = ptzr->get_nalu_size_length();
for (size_t i = 0; i < m_max_video_frames; ++i) {
int size = AVI_frame_size(m_avi, i);
if (0 == size)
continue;
memory_cptr buffer = memory_c::alloc(size);
AVI_set_video_position(m_avi, i);
int key = 0;
size = AVI_read_frame(m_avi, reinterpret_cast<char *>(buffer->get_buffer()), &key);
if ( (4 <= size)
&& ( (get_uint32_be(buffer->get_buffer()) == NALU_START_CODE)
|| (get_uint24_be(buffer->get_buffer()) == NALU_START_CODE)))
m_avc_nal_size_size = -1;
break;
}
AVI_set_video_position(m_avi, 0);
}
/*
* read_frame for video - this will try to read the next frame - it
* tries to be smart about reading it 1 time if we've already read it
* while bookmarking
*/
void CAviVideoByteStream::read_frame (uint32_t frame_to_read)
{
uint32_t next_frame_size;
if (m_frame_in_buffer == frame_to_read) {
m_byte_on = 0;
return;
}
// Haven't already read the next frame, so - get the size, see if
// it fits, then read it into the appropriate buffer
m_parent->lock_file_mutex();
long temp;
AVI_set_video_position(m_parent->get_file(), m_frame_on, &temp);
next_frame_size = temp;
if (next_frame_size > m_max_frame_size) {
m_max_frame_size = next_frame_size;
m_buffer = (uint8_t *)realloc(m_buffer, next_frame_size * sizeof(char) + 4);
}
m_this_frame_size = next_frame_size;
AVI_read_frame(m_parent->get_file(), (char *)m_buffer);
m_parent->unlock_file_mutex();
m_byte_on = 0;
}
void
avi_reader_c::extended_identify_mpeg4_l2(std::vector<std::string> &extended_info) {
int size = AVI_frame_size(m_avi, 0);
if (0 >= size)
return;
memory_cptr af_buffer = memory_c::alloc(size);
unsigned char *buffer = af_buffer->get_buffer();
int dummy_key;
AVI_read_frame(m_avi, reinterpret_cast<char *>(buffer), &dummy_key);
uint32_t par_num, par_den;
if (mpeg4::p2::extract_par(buffer, size, par_num, par_den)) {
int width = AVI_video_width(m_avi);
int height = AVI_video_height(m_avi);
float aspect_ratio = static_cast<float>(width) * par_num / height / par_den;
int disp_width, disp_height;
if (aspect_ratio > (static_cast<float>(width) / height)) {
disp_width = irnd(height * aspect_ratio);
disp_height = height;
} else {
disp_width = width;
disp_height = irnd(width / aspect_ratio);
}
extended_info.push_back((boost::format("display_dimensions:%1%x%2%") % disp_width % disp_height).str());
}
}
void
avi_reader_c::extended_identify_mpeg4_l2(mtx::id::info_c &info) {
int size = AVI_frame_size(m_avi, 0);
if (0 >= size)
return;
memory_cptr af_buffer = memory_c::alloc(size);
unsigned char *buffer = af_buffer->get_buffer();
int dummy_key;
AVI_read_frame(m_avi, reinterpret_cast<char *>(buffer), &dummy_key);
uint32_t par_num, par_den;
if (mpeg4::p2::extract_par(buffer, size, par_num, par_den)) {
auto aspect_ratio = static_cast<double>(m_video_width) * par_num / m_video_height / par_den;
int disp_width, disp_height;
if (aspect_ratio > (static_cast<double>(m_video_width) / m_video_height)) {
disp_width = std::llround(m_video_height * aspect_ratio);
disp_height = m_video_height;
} else {
disp_width = m_video_width;
disp_height = std::llround(m_video_width / aspect_ratio);
}
info.add(mtx::id::display_dimensions, boost::format("%1%x%2%") % disp_width % disp_height);
}
}
/*
* Class: com_mcxiaoke_ndk_Native
* Method: renderNW
* Signature: (JLandroid/view/Surface;)Z
*/
JNIEXPORT jboolean JNICALL Java_com_mcxiaoke_ndk_Native_renderNW
(JNIEnv *env, jclass clazz, jlong avi, jobject surface)
{
jboolean isFrameRead = JNI_FALSE;
long frameSize = 0;
int keyFrame = 0;
// Get the native window from the surface
ANativeWindow* nativeWindow = ANativeWindow_fromSurface(
env, surface);
if (0 == nativeWindow)
{
ThrowException(env, "java/io/RuntimeException",
"Unable to get native window from surface.");
goto exit;
}
// Lock the native window and get access to raw buffer
ANativeWindow_Buffer windowBuffer;
if (0 > ANativeWindow_lock(nativeWindow, &windowBuffer, 0))
{
ThrowException(env, "java/io/RuntimeException",
"Unable to lock native window.");
goto release;
}
// Read AVI frame bytes to raw buffer
frameSize = AVI_read_frame((avi_t*) avi,
(char*) windowBuffer.bits,
&keyFrame);
// Check if frame is successfully read
if (0 < frameSize)
{
isFrameRead = JNI_TRUE;
}
// Unlock and post the buffer for displaying
if (0 > ANativeWindow_unlockAndPost(nativeWindow))
{
ThrowException(env, "java/io/RuntimeException",
"Unable to unlock and post to native window.");
goto release;
}
release:
// Release the native window
ANativeWindow_release(nativeWindow);
nativeWindow = 0;
exit:
return isFrameRead;
}
void
avi_reader_c::create_mpeg1_2_packetizer() {
std::shared_ptr<M2VParser> m2v_parser(new M2VParser);
m2v_parser->SetProbeMode();
if (m_ti.m_private_data && (m_ti.m_private_data->get_size() < sizeof(alBITMAPINFOHEADER)))
m2v_parser->WriteData(m_ti.m_private_data->get_buffer() + sizeof(alBITMAPINFOHEADER), m_ti.m_private_data->get_size() - sizeof(alBITMAPINFOHEADER));
unsigned int frame_number = 0;
unsigned int state = m2v_parser->GetState();
while ((frame_number < std::min(m_max_video_frames, 100u)) && (MPV_PARSER_STATE_FRAME != state)) {
++frame_number;
int size = AVI_frame_size(m_avi, frame_number - 1);
if (0 == size)
continue;
AVI_set_video_position(m_avi, frame_number - 1);
memory_cptr buffer = memory_c::alloc(size);
int key = 0;
int num_read = AVI_read_frame(m_avi, reinterpret_cast<char *>(buffer->get_buffer()), &key);
if (0 >= num_read)
continue;
m2v_parser->WriteData(buffer->get_buffer(), num_read);
state = m2v_parser->GetState();
}
AVI_set_video_position(m_avi, 0);
if (MPV_PARSER_STATE_FRAME != state)
mxerror_tid(m_ti.m_fname, 0, Y("Could not extract the sequence header from this MPEG-1/2 track.\n"));
MPEG2SequenceHeader seq_hdr = m2v_parser->GetSequenceHeader();
std::shared_ptr<MPEGFrame> frame(m2v_parser->ReadFrame());
if (!frame)
mxerror_tid(m_ti.m_fname, 0, Y("Could not extract the sequence header from this MPEG-1/2 track.\n"));
int display_width = ((0 >= seq_hdr.aspectRatio) || (1 == seq_hdr.aspectRatio)) ? seq_hdr.width : static_cast<int>(seq_hdr.height * seq_hdr.aspectRatio);
MPEGChunk *raw_seq_hdr = m2v_parser->GetRealSequenceHeader();
if (raw_seq_hdr)
m_ti.m_private_data = memory_c::clone(raw_seq_hdr->GetPointer(), raw_seq_hdr->GetSize());
else
m_ti.m_private_data.reset();
m_vptzr = add_packetizer(new mpeg1_2_video_packetizer_c(this, m_ti, m2v_parser->GetMPEGVersion(), seq_hdr.frameOrFieldRate,
seq_hdr.width, seq_hdr.height, display_width, seq_hdr.height, false));
show_packetizer_info(0, PTZR(m_vptzr));
}
void
avi_reader_c::debug_dump_video_index() {
int num_video_frames = AVI_video_frames(m_avi), i;
mxinfo(boost::format("AVI video index dump: %1% entries; frame rate: %2%\n") % num_video_frames % m_fps);
for (i = 0; num_video_frames > i; ++i) {
int key = 0;
AVI_read_frame(m_avi, nullptr, &key);
mxinfo(boost::format(" %1%: %2% bytes; key: %3%\n") % i % AVI_frame_size(m_avi, i) % key);
}
AVI_set_video_position(m_avi, 0);
}
static ImBuf *avi_fetchibuf(struct anim *anim, int position)
{
ImBuf *ibuf = NULL;
int *tmp;
int y;
if (anim == NULL) {
return NULL;
}
#if defined(_WIN32) && !defined(FREE_WINDOWS)
if (anim->avistreams) {
LPBITMAPINFOHEADER lpbi;
if (anim->pgf) {
lpbi = AVIStreamGetFrame(anim->pgf, position + AVIStreamStart(anim->pavi[anim->firstvideo]));
if (lpbi) {
ibuf = IMB_ibImageFromMemory((unsigned char *) lpbi, 100, IB_rect, anim->colorspace, "<avi_fetchibuf>");
//Oh brother...
}
}
}
else
#endif
{
ibuf = IMB_allocImBuf(anim->x, anim->y, 24, IB_rect);
tmp = AVI_read_frame(anim->avi, AVI_FORMAT_RGB32, position,
AVI_get_stream(anim->avi, AVIST_VIDEO, 0));
if (tmp == NULL) {
printf("Error reading frame from AVI: '%s'\n", anim->name);
IMB_freeImBuf(ibuf);
return NULL;
}
for (y = 0; y < anim->y; y++) {
memcpy(&(ibuf->rect)[((anim->y - y) - 1) * anim->x], &tmp[y * anim->x],
anim->x * 4);
}
MEM_freeN(tmp);
}
ibuf->rect_colorspace = colormanage_colorspace_get_named(anim->colorspace);
return ibuf;
}
/*
* Class: com_mcxiaoke_ndk_Native
* Method: render
* Signature: (JJ)Z
*/
JNIEXPORT jboolean JNICALL Java_com_mcxiaoke_ndk_Native_renderOpenGL
(JNIEnv *env, jclass clazz, jlong inst, jlong avi)
{
Instance* instance = (Instance*) inst;
jboolean isFrameRead = JNI_FALSE;
int keyFrame = 0;
// Read AVI frame bytes to bitmap
long frameSize = AVI_read_frame((avi_t*) avi,
instance->buffer,
&keyFrame);
// Check if frame read
if (0 >= frameSize)
{
goto exit;
}
// Frame read
isFrameRead = JNI_TRUE;
// Update the texture with the new frame
glTexSubImage2D(GL_TEXTURE_2D,
0,
0,
0,
AVI_video_width((avi_t*) avi),
AVI_video_height((avi_t*) avi),
GL_RGB,
GL_UNSIGNED_SHORT_5_6_5,
instance->buffer);
// Draw texture
glDrawTexiOES(0, 0, 0,
AVI_video_width((avi_t*) avi),
AVI_video_height((avi_t*) avi));
/**
to fix error: glDrawTexiOES was not declared in this scope
add this to Android.mk: LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES
**/
exit:
return isFrameRead;
}
jboolean Java_com_mcxiaoke_ndk_Native_renderBitmap(
JNIEnv* env,
jclass clazz,
jlong avi,
jobject bitmap)
{
jboolean isFrameRead = JNI_FALSE;
char* frameBuffer = 0;
long frameSize = 0;
int keyFrame = 0;
// Lock bitmap and get the raw bytes
if (0 > AndroidBitmap_lockPixels(env, bitmap, (void**) &frameBuffer))
{
ThrowException(env, "java/io/IOException",
"Unable to lock pixels.");
goto exit;
}
// Read AVI frame bytes to bitmap
frameSize = AVI_read_frame((avi_t*) avi, frameBuffer, &keyFrame);
// Unlock bitmap
if (0 > AndroidBitmap_unlockPixels(env, bitmap))
{
ThrowException(env, "java/io/IOException",
"Unable to unlock pixels.");
goto exit;
}
// Check if frame is successfully read
if (0 < frameSize)
{
isFrameRead = JNI_TRUE;
}
exit:
return isFrameRead;
}
/*
* avi2raw
* required arg1 should be the input AVI file
* required arg2 should be the output RAW file
*/
int main(int argc, char** argv)
{
/* configurable variables from command line */
bool extractVideo = TRUE; /* FALSE implies extract audio */
u_int32_t start = 0; /* secs, start offset */
u_int32_t duration = 0; /* secs, 0 implies entire file */
bool quiet = FALSE;
/* internal variables */
char* aviFileName = NULL;
char* rawFileName = NULL;
avi_t* aviFile = NULL;
FILE* rawFile = NULL;
int verbose = FALSE;
u_int32_t numBytes, totBytes = 0;
bool eliminate_short_frames = FALSE;
uint32_t short_frames_len;
/* begin process command line */
progName = argv[0];
while (1) {
int c = -1;
int option_index = 0;
static struct option long_options[] = {
{ "audio", 0, 0, 'a' },
{ "eliminate-short-frames", optional_argument, 0, 'e'},
{ "length", 1, 0, 'l' },
{ "quiet", 0, 0, 'q' },
{ "start", 1, 0, 's' },
{ "video", 0, 0, 'v' },
{ "version", 0, 0, 'V'},
{ "verbose", 0, 0, 'R'},
{ "help", 0, 0, 'h'},
{ NULL, 0, 0, 0 }
};
c = getopt_long_only(argc, argv, "ael:qs:vVh",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'h':
fprintf(stderr, "%s - %s version %s\n", progName,
MPEG4IP_PACKAGE, MPEG4IP_VERSION);
fprintf(stderr, "options:\n");
fprintf(stderr, " --audio - extract audio track\n");
fprintf(stderr, " --length <length> - extract <length> secs\n");
fprintf(stderr, " --quiet - quiet mode\n");
fprintf(stderr, " --start <time> - extract from <start> time\n");
fprintf(stderr, " --video - extract video track\n");
fprintf(stderr, " --eliminate-short-frames <bytes> - eliminate short frames of bytes or less - default 4\n");
return 0;
case 'a': {
extractVideo = FALSE;
break;
}
case 'e':
eliminate_short_frames = TRUE;
if (optarg) {
if (optarg[0] == '=') optarg[0] = ' ';
if (sscanf(optarg, "%u", &short_frames_len) != 1) {
fprintf(stderr, "%s:bad eliminate length %s\n",
progName, optarg);
}
} else {
short_frames_len = 4;
}
break;
case 'l': {
/* --length=<secs> */
u_int i;
if (sscanf(optarg, "%u", &i) < 1) {
fprintf(stderr,
"%s: bad length specified: %s\n",
progName, optarg);
} else {
duration = i;
}
break;
}
case 'q': {
quiet = TRUE;
break;
}
case 's': {
/* --start=<secs> */
u_int i;
if (sscanf(optarg, "%u", &i) < 1) {
fprintf(stderr,
"%s: bad start specified: %s\n",
progName, optarg);
} else {
start = i;
}
break;
}
case 'v': {
extractVideo = TRUE;
break;
}
case '?':
break;
case 'R':
verbose = TRUE; quiet = FALSE;
break;
case 'V':
fprintf(stderr, "%s - %s version %s\n", progName,
MPEG4IP_PACKAGE, MPEG4IP_VERSION);
return(0);
default:
fprintf(stderr, "%s: unknown option specified, ignoring: %c\n",
progName, c);
}
}
/* check that we have at least two non-option arguments */
if ((argc - optind) < 2) {
fprintf(stderr,
"usage: %s <avi-file> <raw-file>\n",
progName);
exit(1);
}
/* point to the specified file names */
aviFileName = argv[optind++];
rawFileName = argv[optind++];
/* warn about extraneous non-option arguments */
if (optind < argc) {
fprintf(stderr, "%s: unknown options specified, ignoring: ", progName);
while (optind < argc) {
fprintf(stderr, "%s ", argv[optind++]);
}
fprintf(stderr, "\n");
}
/* end processing of command line */
/* open the AVI file */
aviFile = AVI_open_input_file(aviFileName, TRUE);
if (aviFile == NULL) {
fprintf(stderr,
"%s: error %s: %s\n",
progName, aviFileName, AVI_strerror());
exit(4);
}
if (!quiet) {
fprintf(stderr, "%s - %s version %s\n",
progName, MPEG4IP_PACKAGE, MPEG4IP_VERSION);
}
/* open the RAW file */
rawFile = fopen(rawFileName, "wb");
if (rawFile == NULL) {
fprintf(stderr,
"%s: error opening %s: %s\n",
progName, rawFileName, strerror(errno));
exit(5);
}
if (extractVideo) {
double videoFrameRate = AVI_video_frame_rate(aviFile);
u_int32_t numVideoFrames = AVI_video_frames(aviFile);
u_int32_t fileDuration = ceil(numVideoFrames / videoFrameRate);
u_int32_t numDesiredVideoFrames;
u_int32_t videoFramesRead = 0;
u_int32_t emptyFramesRead = 0;
/* get a buffer large enough to handle a frame of raw SDTV */
u_char* buf = (u_char*)malloc(768 * 576 * 4);
if (duration) {
numDesiredVideoFrames = duration * videoFrameRate;
} else {
numDesiredVideoFrames = numVideoFrames;
}
if (buf == NULL) {
fprintf(stderr,
"%s: error allocating memory: %s\n",
progName, strerror(errno));
exit(6);
}
/* check that start offset is valid */
if (start > fileDuration) {
fprintf(stderr,
"%s: specified start is past the end of the file\n",
progName);
exit(7);
}
if (AVI_seek_start(aviFile)) {
fprintf(stderr,
"%s: bad seek: %s\n",
progName, AVI_strerror());
exit(8);
}
if (AVI_set_video_position(aviFile, (long) ROUND(start * videoFrameRate), NULL)) {
fprintf(stderr,
"%s: bad seek: %s\n",
progName, AVI_strerror());
exit(9);
}
#ifdef DEBUG_H264
h264_decode_t dec;
#endif
while (TRUE) {
numBytes = AVI_read_frame(aviFile, (char *)buf);
/* read error */
if (numBytes < 0) {
break;
}
totBytes += numBytes;
videoFramesRead++;
if (verbose) {
printf("frame %d - len %u total %u\n",
videoFramesRead, numBytes, totBytes);
}
/*
* note some capture programs
* insert a zero length frame occasionally
* hence numBytes == 0, but we're not a EOF
*/
if ((eliminate_short_frames && numBytes > short_frames_len) ||
(eliminate_short_frames == FALSE && numBytes)) {
// test
#ifdef DEBUG_H264
uint32_t offset = 0, read;
do {
if (h264_is_start_code(buf + offset)) {
int ret =
h264_detect_boundary(buf + offset,
numBytes - offset,
&dec);
printf(" frame offset %d nal type %d slice %d %d\n",
offset,
dec.nal_unit_type,
dec.slice_type,
ret);
}
read = h264_find_next_start_code(buf + offset,
numBytes - offset);
offset += read;
} while (read != 0 && offset < numBytes);
#endif
if (fwrite(buf, 1, numBytes, rawFile) != numBytes) {
fprintf(stderr,
"%s: error writing %s: %s\n",
progName, rawFileName, strerror(errno));
break;
}
} else {
emptyFramesRead++;
}
if (videoFramesRead >= numDesiredVideoFrames) {
break;
}
}
if (verbose) {
printf("read %u video bytes\n", totBytes);
}
if (numBytes < 0) {
printf("%s: error reading %s, frame %d, %s\n",
progName, aviFileName, videoFramesRead + 1, AVI_strerror());
}
if (videoFramesRead < numDesiredVideoFrames) {
fprintf(stderr,
"%s: warning: could only extract %u seconds of video (%u of %u frames)\n",
progName, (unsigned int)ceil(videoFramesRead / videoFrameRate),
videoFramesRead, numDesiredVideoFrames);
}
if (emptyFramesRead) {
fprintf(stderr,
"%s: warning: %u zero length frames ignored\n",
progName, emptyFramesRead);
}
if (!quiet) {
printf("%u video frames written\n",
videoFramesRead - emptyFramesRead);
}
/* cleanup */
free(buf);
} else {
/* extract audio */
u_int32_t audioBytesRead = 0;
u_char *buf = (u_char*) malloc(8*1024);
u_int32_t numDesiredAudioBytes = AVI_audio_bytes(aviFile);
u_int32_t audioBytesPerSec = 0;
if (start != 0) {
u_int32_t numAudioBytes = numDesiredAudioBytes;
u_int32_t fileDuration;
audioBytesPerSec = AVI_audio_rate(aviFile) *
((AVI_audio_bits(aviFile) + 7) / 8) * AVI_audio_channels(aviFile);
fileDuration = ceil(numAudioBytes / audioBytesPerSec);
numDesiredAudioBytes = duration * audioBytesPerSec;
/* check that start offset is valid */
if (start > fileDuration) {
fprintf(stderr,
"%s: specified start is past the end of the file\n",
progName);
exit(7);
}
if (AVI_seek_start(aviFile)) {
fprintf(stderr,
"%s: bad seek: %s\n",
progName, AVI_strerror());
exit(8);
}
if (AVI_set_audio_position(aviFile, start * audioBytesPerSec)) {
fprintf(stderr,
"%s: bad seek: %s\n",
progName, AVI_strerror());
exit(9);
}
} else {
if (AVI_seek_start(aviFile)) {
fprintf(stderr,
"%s: bad seek: %s\n",
progName, AVI_strerror());
exit(8);
}
if (AVI_set_audio_position(aviFile, 0)) {
fprintf(stderr,
"%s: bad seek: %s\n",
progName, AVI_strerror());
exit(9);
}
}
while ((numBytes = AVI_read_audio(aviFile, (char *)buf, sizeof(buf))) > 0) {
if (fwrite(buf, 1, numBytes, rawFile) != numBytes) {
fprintf(stderr,
"%s: error writing %s: %s\n",
progName, rawFileName, strerror(errno));
break;
}
audioBytesRead += numBytes;
if (numDesiredAudioBytes
&& audioBytesRead >= numDesiredAudioBytes) {
break;
}
}
if (verbose) {
printf("read %u audio bytes\n", audioBytesRead);
}
if (duration && audioBytesRead < numDesiredAudioBytes) {
fprintf(stderr,
"%s: warning: could only extract %u seconds of audio\n",
progName, audioBytesPerSec == 0 ? audioBytesRead : audioBytesRead / audioBytesPerSec);
}
if (!quiet && AVI_audio_bits(aviFile) != 0) {
printf("%u audio samples written\n",
audioBytesRead / ((AVI_audio_bits(aviFile) + 7) / 8));
}
}
/* cleanup */
AVI_close(aviFile);
fclose(rawFile);
return(0);
}
file_status_e
avi_reader_c::read_video() {
if (m_video_frames_read >= m_max_video_frames)
return flush_packetizer(m_vptzr);
memory_cptr chunk;
int key = 0;
int old_video_frames_read = m_video_frames_read;
int size, num_read;
int dropped_frames_here = 0;
do {
size = AVI_frame_size(m_avi, m_video_frames_read);
chunk = memory_c::alloc(size);
num_read = AVI_read_frame(m_avi, reinterpret_cast<char *>(chunk->get_buffer()), &key);
++m_video_frames_read;
if (0 > num_read) {
// Error reading the frame: abort
m_video_frames_read = m_max_video_frames;
return flush_packetizer(m_vptzr);
} else if (0 == num_read)
++dropped_frames_here;
} while ((0 == num_read) && (m_video_frames_read < m_max_video_frames));
if (0 == num_read)
// This is only the case if the AVI contains dropped frames only.
return flush_packetizer(m_vptzr);
size_t i;
for (i = m_video_frames_read; i < m_max_video_frames; ++i) {
if (0 != AVI_frame_size(m_avi, i))
break;
int dummy_key;
AVI_read_frame(m_avi, nullptr, &dummy_key);
++dropped_frames_here;
++m_video_frames_read;
}
int64_t timestamp = static_cast<int64_t>(static_cast<int64_t>(old_video_frames_read) * 1000000000ll / m_fps);
int64_t duration = static_cast<int64_t>(static_cast<int64_t>(dropped_frames_here + 1) * 1000000000ll / m_fps);
m_dropped_video_frames += dropped_frames_here;
// AVC with framed packets (without NALU start codes but with length fields)
// or non-AVC video track?
if (0 >= m_avc_nal_size_size)
PTZR(m_vptzr)->process(new packet_t(chunk, timestamp, duration, key ? VFT_IFRAME : VFT_PFRAMEAUTOMATIC, VFT_NOBFRAME));
else {
// AVC video track without NALU start codes. Re-frame with NALU start codes.
int offset = 0;
while ((offset + m_avc_nal_size_size) < num_read) {
int nalu_size = get_uint_be(chunk->get_buffer() + offset, m_avc_nal_size_size);
offset += m_avc_nal_size_size;
if ((offset + nalu_size) > num_read)
break;
memory_cptr nalu = memory_c::alloc(4 + nalu_size);
put_uint32_be(nalu->get_buffer(), NALU_START_CODE);
memcpy(nalu->get_buffer() + 4, chunk->get_buffer() + offset, nalu_size);
offset += nalu_size;
PTZR(m_vptzr)->process(new packet_t(nalu, timestamp, duration, key ? VFT_IFRAME : VFT_PFRAMEAUTOMATIC, VFT_NOBFRAME));
}
}
m_bytes_processed += num_read;
return m_video_frames_read >= m_max_video_frames ? flush_packetizer(m_vptzr) : FILE_STATUS_MOREDATA;
}
int main(int argc, char *argv[]) {
int opt_shutter_angle = 0;
int opt_mjpeg_quality = 100;
int nf, i, nc, nr;
int tfs, fps;
vc *pos_i, *pos_h, *pos_y;
es_ctx *es;
rs_ctx *rs;
opterr = 0;
while ((i = getopt(argc, argv, "r:q:")) != -1) {
switch (i) {
case 'r':
opt_shutter_angle = atoi(optarg);
break;
case 'q':
opt_mjpeg_quality = atoi(optarg);
break;
default:
print_help(argv);
}
}
if (argc < optind + 2)
print_help(argv);
if (AVI_open_movie(argv[optind], &mv_in) != AVI_ERROR_NONE) {
printf("error: can't read from %s\n", argv[optind]);
return EXIT_FAILURE;
}
if (mv_in.header->Streams < 1 || mv_in.streams[0].sh.Type != AVIST_VIDEO) {
printf("error: video stream not found on %s\n", argv[optind]);
return EXIT_FAILURE;
}
if (AVI_open_compress(argv[optind + 1], &mv_out, 1, AVI_FORMAT_MJPEG) != AVI_ERROR_NONE) {
printf("error: can't write to %s\n", argv[optind + 1]);
return EXIT_FAILURE;
}
printf("status: setup\n");
prepare_lanc_kernels();
nc = mv_in.header->Width;
nr = mv_in.header->Height;
tfs = mv_in.header->TotalFrames;
fps = 1000000 / mv_in.header->MicroSecPerFrame;
pos_i = (vc *)malloc(tfs * sizeof(vc));
pos_h = (vc *)malloc(tfs * sizeof(vc));
pos_y = (vc *)malloc(nr * sizeof(vc));
AVI_set_compress_option(&mv_out, AVI_OPTION_TYPE_MAIN, 0, AVI_OPTION_WIDTH, &nc);
AVI_set_compress_option(&mv_out, AVI_OPTION_TYPE_MAIN, 0, AVI_OPTION_HEIGHT, &nr);
AVI_set_compress_option(&mv_out, AVI_OPTION_TYPE_MAIN, 0, AVI_OPTION_FRAMERATE, &fps);
AVI_set_compress_option(&mv_out, AVI_OPTION_TYPE_MAIN, 0, AVI_OPTION_QUALITY, &opt_mjpeg_quality);
es = es_init(nc, nr);
rs = rs_init(nc, nr);
printf("status: estimating\n");
for (nf = 0; nf < tfs; nf ++) {
unsigned char *fr = (unsigned char *)AVI_read_frame(&mv_in, AVI_FORMAT_RGB24, nf, 0);
pos_i[nf] = vc_add(
nf > 0 ? pos_i[nf - 1] : vc_set(0.0, 0.0),
es_estimate(es, fr)
);
free(fr);
if ((nf + 1) % 10 == 0) {
printf(".");
fflush(stdout);
}
}
printf("\nstatus: filtering\n");
hipass(pos_i, pos_h, tfs, fps / 2);
printf("status: resampling\n");
for (nf = 0; nf < tfs; nf ++) {
unsigned char *fr = (unsigned char *)AVI_read_frame(&mv_in, AVI_FORMAT_RGB24, nf, 0);
for (i = 0; i < nr; i ++) {
pos_y[i] = interp(
pos_h, tfs,
nf + (i - nr / 2.0) * opt_shutter_angle / (nr * 360.0)
);
}
rs_resample(rs, fr, pos_y);
AVI_write_frame(&mv_out, nf, AVI_FORMAT_RGB24, fr, nc * nr * 3 * sizeof(unsigned char));
if ((nf + 1) % 10 == 0) {
printf(".");
fflush(stdout);
}
}
printf("\nstatus: closing\n");
es_free(es);
rs_free(rs);
free_lanc_kernels();
AVI_close(&mv_in);
AVI_close_compress(&mv_out);
return EXIT_SUCCESS;
}
void extract_rgb(info_t *ipipe)
{
uint8_t *video;
avi_t *avifile = NULL;
int key, error = 0;
long frames, bytes, n;
switch (ipipe->magic) {
case TC_MAGIC_AVI:
if (ipipe->nav_seek_file) {
avifile = AVI_open_indexfd(ipipe->fd_in, 0, ipipe->nav_seek_file);
} else {
avifile = AVI_open_fd(ipipe->fd_in, 1);
}
if (NULL == avifile) {
AVI_print_error("AVI open");
import_exit(1);
}
frames = AVI_video_frames(avifile);
if (ipipe->frame_limit[1] < frames) {
frames = ipipe->frame_limit[1];
}
if (ipipe->verbose & TC_STATS) {
tc_log_msg(__FILE__, "%ld video frames", frames);
}
video = tc_bufalloc(SIZE_RGB_FRAME);
if (!video) {
error = 1;
break;
}
AVI_set_video_position(avifile, ipipe->frame_limit[0]);
/* FIXME: should this be < rather than <= ? */
for (n = ipipe->frame_limit[0]; n <= frames; n++) {
bytes = AVI_read_frame(avifile, video, &key);
if (bytes < 0) {
error = 1;
break;
}
if (tc_pwrite(ipipe->fd_out, video, bytes) != bytes) {
error = 1;
break;
}
}
tc_buffree(video);
break;
case TC_MAGIC_RAW: /* fallthrough */
default:
if (ipipe->magic == TC_MAGIC_UNKNOWN) {
tc_log_warn(__FILE__, "no file type specified, assuming %s",
filetype(TC_MAGIC_RAW));
error = tc_preadwrite(ipipe->fd_in, ipipe->fd_out);
break;
}
}
if (error) {
tc_log_perror(__FILE__, "error while writing data");
import_exit(error);
}
}
int main(int argc, char *argv[])
{
avi_t *avifile1=NULL;
avi_t *avifile2=NULL;
avi_t *avifile3=NULL;
char *in_file=NULL, *out_file=NULL;
long frames, bytes;
double fps;
char *codec;
int track_num=0, aud_tracks;
int encode_null=0;
int i, j, n, key, shift=0;
int ch, preload=0;
long rate, mp3rate;
int width, height, format, chan, bits;
int be_quiet = 0;
FILE *status_fd = stderr;
/* for null frame encoding */
char nulls[32000];
long nullbytes=0;
char tmp0[] = "/tmp/nullfile.00.avi"; /* XXX: use mktemp*() */
buffer_list_t *ptr;
double vid_ms = 0.0, shift_ms = 0.0, one_vid_ms = 0.0;
double aud_ms [ AVI_MAX_TRACKS ];
int aud_bitrate = 0;
int aud_chunks = 0;
ac_init(AC_ALL);
if(argc==1) usage(EXIT_FAILURE);
while ((ch = getopt(argc, argv, "a:b:vi:o:n:Nq?h")) != -1)
{
switch (ch) {
case 'i':
if(optarg[0]=='-') usage(EXIT_FAILURE);
in_file=optarg;
break;
case 'a':
if(optarg[0]=='-') usage(EXIT_FAILURE);
track_num = atoi(optarg);
if(track_num<0) usage(EXIT_FAILURE);
break;
case 'b':
if(optarg[0]=='-') usage(EXIT_FAILURE);
is_vbr = atoi(optarg);
if(is_vbr<0) usage(EXIT_FAILURE);
break;
case 'o':
if(optarg[0]=='-') usage(EXIT_FAILURE);
out_file=optarg;
break;
case 'f':
if(optarg[0]=='-') usage(EXIT_FAILURE);
comfile = optarg;
break;
case 'n':
if(sscanf(optarg,"%d", &shift)!=1) {
fprintf(stderr, "invalid parameter for option -n\n");
usage(EXIT_FAILURE);
}
break;
case 'N':
encode_null=1;
break;
case 'q':
be_quiet = 1;
break;
case 'v':
version();
exit(0);
break;
case 'h':
usage(EXIT_SUCCESS);
default:
usage(EXIT_FAILURE);
}
}
// check
if(in_file==NULL || out_file == NULL) usage(EXIT_FAILURE);
if(shift == 0) fprintf(stderr, "no sync requested - exit");
memset (nulls, 0, sizeof(nulls));
// open file
if(NULL == (avifile1 = AVI_open_input_file(in_file,1))) {
AVI_print_error("AVI open");
exit(1);
}
if(strcmp(in_file, out_file)==0) {
printf("error: output filename conflicts with input filename\n");
exit(1);
}
if(NULL == (avifile2 = AVI_open_output_file(out_file))) {
AVI_print_error("AVI open");
exit(1);
}
if (be_quiet) {
if (!(status_fd = fopen("/dev/null", "w"))) {
fprintf(stderr, "Can't open /dev/null\n");
exit(1);
}
}
// read video info;
AVI_info(avifile1);
// read video info;
frames = AVI_video_frames(avifile1);
width = AVI_video_width(avifile1);
height = AVI_video_height(avifile1);
fps = AVI_frame_rate(avifile1);
codec = AVI_video_compressor(avifile1);
//set video in outputfile
AVI_set_video(avifile2, width, height, fps, codec);
if (comfile!=NULL)
AVI_set_comment_fd(avifile2, open(comfile, O_RDONLY));
aud_tracks = AVI_audio_tracks(avifile1);
for(j=0; j<aud_tracks; ++j) {
AVI_set_audio_track(avifile1, j);
rate = AVI_audio_rate(avifile1);
chan = AVI_audio_channels(avifile1);
bits = AVI_audio_bits(avifile1);
format = AVI_audio_format(avifile1);
mp3rate= AVI_audio_mp3rate(avifile1);
//set next track of output file
AVI_set_audio_track(avifile2, j);
AVI_set_audio(avifile2, chan, rate, bits, format, mp3rate);
AVI_set_audio_vbr(avifile2, is_vbr);
}
//switch to requested audio_channel
if(AVI_set_audio_track(avifile1, track_num)<0) {
fprintf(stderr, "invalid auto track\n");
}
AVI_set_audio_track(avifile2, track_num);
if (encode_null) {
char cmd[1024];
rate = AVI_audio_rate(avifile2);
chan = AVI_audio_channels(avifile2);
bits = AVI_audio_bits(avifile2);
format = AVI_audio_format(avifile2);
mp3rate= AVI_audio_mp3rate(avifile2);
if (bits==0) bits=16;
if (mp3rate%2) mp3rate++;
fprintf(status_fd, "Creating silent mp3 frame with current parameter\n");
memset (cmd, 0, sizeof(cmd));
tc_snprintf(cmd, sizeof(cmd), "transcode -i /dev/zero -o %s -x raw,raw"
" -n 0x1 -g 16x16 -y raw,raw -c 0-5 -e %ld,%d,%d -b %ld -q0",
tmp0, rate,bits,chan, mp3rate);
printf(cmd);
system(cmd);
if(NULL == (avifile3 = AVI_open_input_file(tmp0,1))) {
AVI_print_error("AVI open");
exit(1);
}
nullbytes = AVI_audio_size(avifile3, 3);
/* just read a few frames */
if(AVI_read_audio(avifile3, nulls, nullbytes) < 0) {
AVI_print_error("AVI audio read frame");
return(-1);
}
memset (nulls, 0, sizeof(nulls));
if(AVI_read_audio(avifile3, nulls, nullbytes) < 0) {
AVI_print_error("AVI audio read frame");
return(-1);
}
memset (nulls, 0, sizeof(nulls));
if(AVI_read_audio(avifile3, nulls, nullbytes) < 0) {
AVI_print_error("AVI audio read frame");
return(-1);
}
/*
printf("\nBytes (%ld): \n", nullbytes);
{
int asd=0;
for (asd=0; asd<nullbytes; asd++){
printf("%x ",(unsigned char)nulls[asd]);
}
printf("\n");
}
*/
}
vid_ms = 0.0;
shift_ms = 0.0;
for (n=0; n<AVI_MAX_TRACKS; ++n)
aud_ms[n] = 0.0;
// ---------------------------------------------------------------------
for (n=0; n<frames; ++n) {
// video unchanged
bytes = AVI_read_frame(avifile1, data, &key);
if(bytes < 0) {
AVI_print_error("AVI read video frame");
return(-1);
}
if(AVI_write_frame(avifile2, data, bytes, key)<0) {
AVI_print_error("AVI write video frame");
return(-1);
}
vid_ms = (n+1)*1000.0/fps;
// Pass-through all other audio tracks.
for(j=0; j<aud_tracks; ++j) {
// skip track we want to modify
if (j == track_num) continue;
// switch to track
AVI_set_audio_track(avifile1, j);
AVI_set_audio_track(avifile2, j);
sync_audio_video_avi2avi(vid_ms, &aud_ms[j], avifile1, avifile2);
}
//switch to requested audio_channel
if(AVI_set_audio_track(avifile1, track_num)<0) {
fprintf(stderr, "invalid auto track\n");
}
AVI_set_audio_track(avifile2, track_num);
shift_ms = (double)shift*1000.0/fps;
one_vid_ms = 1000.0/fps;
format = AVI_audio_format(avifile1);
rate = AVI_audio_rate(avifile1);
chan = AVI_audio_channels(avifile1);
bits = AVI_audio_bits(avifile1);
bits = bits==0?16:bits;
mp3rate= AVI_audio_mp3rate(avifile1);
if(shift>0) {
// for n < shift, shift audio frames are discarded
if(!preload) {
if (tc_format_ms_supported(format)) {
for(i=0;i<shift;++i) {
//fprintf (stderr, "shift (%d) i (%d) n (%d) a (%d)\n", shift, i, n, aud_chunks);
while (aud_ms[track_num] < vid_ms + one_vid_ms*(double)i) {
aud_bitrate = (format==0x1||format==0x2000)?1:0;
aud_chunks++;
if( (bytes = AVI_read_audio_chunk(avifile1, data)) <= 0) {
aud_ms[track_num] = vid_ms + one_vid_ms*i;
if (bytes == 0) continue;
AVI_print_error("AVI 2 audio read frame");
break;
}
if ( !aud_bitrate && tc_get_audio_header(data, bytes, format, NULL, NULL, &aud_bitrate)<0) {
// if this is the last frame of the file, slurp in audio chunks
if (n == frames-1) continue;
aud_ms[track_num] = vid_ms + one_vid_ms*i;
} else
aud_ms[track_num] += (bytes*8.0)/(format==0x1?((double)(rate*chan*bits)/1000.0):
(format==0x2000?(double)(mp3rate):aud_bitrate));
}
}
} else { // fallback
bytes=0;
for(i=0;i<shift;++i) {
do {
if( (bytes = AVI_read_audio_chunk(avifile1, data)) < 0) {
AVI_print_error("AVI audio read frame");
return(-1);
}
} while (AVI_can_read_audio(avifile1));
}
}
preload=1;
}
// copy rest of the track
if(n<frames-shift) {
if (tc_format_ms_supported(format)) {
while (aud_ms[track_num] < vid_ms + shift_ms) {
aud_chunks++;
aud_bitrate = (format==0x1||format==0x2000)?1:0;
if( (bytes = AVI_read_audio_chunk(avifile1, data)) < 0) {
aud_ms[track_num] = vid_ms + shift_ms;
AVI_print_error("AVI 3 audio read frame");
break;
}
if(AVI_write_audio(avifile2, data, bytes) < 0) {
AVI_print_error("AVI 3 write audio frame");
return(-1);
}
fprintf(status_fd, "V [%05d][%08.2f] | A [%05d][%08.2f] [%05ld]\r", n, vid_ms, aud_chunks, aud_ms[track_num], bytes);
if (bytes == 0) {
aud_ms[track_num] = vid_ms + shift_ms;
continue;
}
if(n>=frames-2*shift) {
// save audio frame for later
ptr = buffer_register(n);
if(ptr==NULL) {
fprintf(stderr,"buffer allocation failed\n");
break;
}
ac_memcpy(ptr->data, data, bytes);
ptr->size = bytes;
ptr->status = BUFFER_READY;
}
if ( !aud_bitrate && tc_get_audio_header(data, bytes, format, NULL, NULL, &aud_bitrate)<0) {
if (n == frames-1) continue;
aud_ms[track_num] = vid_ms + shift_ms;
} else
aud_ms[track_num] += (bytes*8.0)/(format==0x1?((double)(rate*chan*bits)/1000.0):
(format==0x2000?(double)(mp3rate):aud_bitrate));
}
} else { // fallback
bytes = AVI_audio_size(avifile1, n+shift-1);
do {
if( (bytes = AVI_read_audio_chunk(avifile1, data)) < 0) {
AVI_print_error("AVI audio read frame");
return(-1);
}
if(AVI_write_audio(avifile2, data, bytes) < 0) {
AVI_print_error("AVI write audio frame");
return(-1);
}
fprintf(status_fd, "V [%05d] | A [%05d] [%05ld]\r", n, n+shift, bytes);
if(n>=frames-2*shift) {
// save audio frame for later
ptr = buffer_register(n);
if(ptr==NULL) {
fprintf(stderr,"buffer allocation failed\n");
break;
}
ac_memcpy(ptr->data, data, bytes);
ptr->size = bytes;
ptr->status = BUFFER_READY;
}
} while (AVI_can_read_audio(avifile1));
}
}
// padding at the end
if(n>=frames-shift) {
if (!ptrlen) {
ptr = buffer_retrieve();
ac_memcpy (ptrdata, ptr->data, ptr->size);
ptrlen = ptr->size;
}
if (tc_format_ms_supported(format)) {
while (aud_ms[track_num] < vid_ms + shift_ms) {
aud_bitrate = (format==0x1||format==0x2000)?1:0;
// mute this -- check if can mute (valid A header)!
if (tc_probe_audio_header(ptrdata, ptrlen) > 0)
tc_format_mute(ptrdata, ptrlen, format);
if(AVI_write_audio(avifile2, ptrdata, ptrlen) < 0) {
AVI_print_error("AVI write audio frame");
return(-1);
}
fprintf(status_fd, " V [%05d][%08.2f] | A [%05d][%08.2f] [%05ld]\r", n, vid_ms, n+shift, aud_ms[track_num], bytes);
if ( !aud_bitrate && tc_get_audio_header(ptrdata, ptrlen, format, NULL, NULL, &aud_bitrate)<0) {
//if (n == frames-1) continue;
aud_ms[track_num] = vid_ms + shift_ms;
} else
aud_ms[track_num] += (ptrlen*8.0)/(format==0x1?((double)(rate*chan*bits)/1000.0):
(format==0x2000?(double)(mp3rate):aud_bitrate));
}
} else { // fallback
// get next audio frame
ptr = buffer_retrieve();
while (1) {
printf("ptr->id (%d) ptr->size (%d)\n", ptr->id, ptr->size);
if(ptr==NULL) {
fprintf(stderr,"no buffer found\n");
break;
}
if (encode_null) {
if(AVI_write_audio(avifile2, nulls, nullbytes)<0) {
AVI_print_error("AVI write audio frame");
return(-1);
}
} else {
// simple keep old frames to force exact time delay
if(AVI_write_audio(avifile2, ptr->data, ptr->size)<0) {
AVI_print_error("AVI write audio frame");
return(-1);
}
}
fprintf(status_fd, "V [%05d] | padding\r", n);
if (ptr->next && ptr->next->id == ptr->id) {
buffer_remove(ptr);
ptr = buffer_retrieve();
continue;
}
buffer_remove(ptr);
break;
} // 1
}
}
// *************************************
// negative shift (pad audio at start)
// *************************************
} else {
if (tc_format_ms_supported(format)) {
/*
fprintf(status_fd, "n(%d) -shift(%d) shift_ms (%.2lf) vid_ms(%.2lf) aud_ms[%d](%.2lf) v-s(%.2lf)\n",
n, -shift, shift_ms, vid_ms, track_num, aud_ms[track_num], vid_ms + shift_ms);
*/
// shift<0 -> shift_ms<0 !
while (aud_ms[track_num] < vid_ms) {
/*
fprintf(stderr, " 1 (%02d) %s frame_read len=%4ld (A/V) (%8.2f/%8.2f)\n",
n, format==0x55?"MP3":"AC3", bytes, aud_ms[track_num], vid_ms);
*/
aud_bitrate = (format==0x1||format==0x2000)?1:0;
if( (bytes = AVI_read_audio_chunk(avifile1, data)) < 0) {
AVI_print_error("AVI 2 audio read frame");
aud_ms[track_num] = vid_ms;
break;
//return(-1);
}
// save audio frame for later
ptr = buffer_register(n);
if(ptr==NULL) {
fprintf(stderr,"buffer allocation failed\n");
break;
}
ac_memcpy(ptr->data, data, bytes);
ptr->size = bytes;
ptr->status = BUFFER_READY;
if(n<-shift) {
// mute this -- check if can mute!
if (tc_probe_audio_header(data, bytes) > 0)
tc_format_mute(data, bytes, format);
// simple keep old frames to force exact time delay
if(AVI_write_audio(avifile2, data, bytes)<0) {
AVI_print_error("AVI write audio frame");
return(-1);
}
fprintf(status_fd, "V [%05d] | padding\r", n);
} else {
if (n==-shift)
fprintf(status_fd, "\n");
// get next audio frame
ptr = buffer_retrieve();
if(ptr==NULL) {
fprintf(stderr,"no buffer found\n");
break;
}
if(AVI_write_audio(avifile2, ptr->data, ptr->size)<0) {
AVI_print_error("AVI write audio frame");
return(-1);
}
bytes = ptr->size;
ac_memcpy (data, ptr->data, bytes);
fprintf(status_fd, "V [%05d] | A [%05d]\r", n, ptr->id);
buffer_remove(ptr);
}
if ( !aud_bitrate && tc_get_audio_header(data, bytes, format, NULL, NULL, &aud_bitrate)<0) {
if (n == frames-1) continue;
aud_ms[track_num] = vid_ms;
} else
aud_ms[track_num] += (bytes*8.0)/(format==0x1?((double)(rate*chan*bits)/1000.0):
(format==0x2000?(double)(mp3rate):aud_bitrate));
/*
fprintf(stderr, " 1 (%02d) %s frame_read len=%4ld (A/V) (%8.2f/%8.2f)\n",
n, format==0x55?"MP3":"AC3", bytes, aud_ms[track_num], vid_ms);
*/
}
} else { // no supported format
bytes = AVI_audio_size(avifile1, n);
if(bytes > SIZE_RGB_FRAME) {
fprintf(stderr, "invalid frame size\n");
return(-1);
}
if(AVI_read_audio(avifile1, data, bytes) < 0) {
AVI_print_error("AVI audio read frame");
return(-1);
}
// save audio frame for later
ptr = buffer_register(n);
if(ptr==NULL) {
fprintf(stderr,"buffer allocation failed\n");
break;
}
ac_memcpy(ptr->data, data, bytes);
ptr->size = bytes;
ptr->status = BUFFER_READY;
if(n<-shift) {
if (encode_null) {
if(AVI_write_audio(avifile2, nulls, nullbytes)<0) {
AVI_print_error("AVI write audio frame");
return(-1);
}
} else {
// simple keep old frames to force exact time delay
if(AVI_write_audio(avifile2, data, bytes)<0) {
AVI_print_error("AVI write audio frame");
return(-1);
}
}
fprintf(status_fd, "V [%05d] | padding\r", n);
} else {
// get next audio frame
ptr = buffer_retrieve();
if(ptr==NULL) {
fprintf(stderr,"no buffer found\n");
break;
}
if(AVI_write_audio(avifile2, ptr->data, ptr->size)<0) {
AVI_print_error("AVI write audio frame");
return(-1);
}
fprintf(status_fd, "V [%05d] | A [%05d]\r", n, ptr->id);
buffer_remove(ptr);
}
}
}
}
fprintf(status_fd, "\n");
if (be_quiet) {
fclose(status_fd);
}
AVI_close(avifile1);
AVI_close(avifile2);
if (avifile3) {
memset(nulls, 0, sizeof(nulls));
tc_snprintf(nulls, sizeof(nulls), "rm -f %s", tmp0);
system(nulls);
AVI_close(avifile3);
}
return(0);
}
static ImBuf *avi_fetchibuf(struct anim *anim, int position)
{
ImBuf *ibuf = NULL;
int *tmp;
int y;
if (anim == NULL) {
return NULL;
}
#if defined(_WIN32) && !defined(FREE_WINDOWS)
if (anim->avistreams) {
LPBITMAPINFOHEADER lpbi;
if (anim->pgf) {
lpbi = AVIStreamGetFrame(anim->pgf, position + AVIStreamStart(anim->pavi[anim->firstvideo]));
if (lpbi) {
ibuf = IMB_ibImageFromMemory((unsigned char *) lpbi, 100, IB_rect, anim->colorspace, "<avi_fetchibuf>");
//Oh brother...
}
}
}
else {
#else
if (1) {
#endif
ibuf = IMB_allocImBuf(anim->x, anim->y, 24, IB_rect);
tmp = AVI_read_frame(anim->avi, AVI_FORMAT_RGB32, position,
AVI_get_stream(anim->avi, AVIST_VIDEO, 0));
if (tmp == NULL) {
printf("Error reading frame from AVI: '%s'\n", anim->name);
IMB_freeImBuf(ibuf);
return NULL;
}
for (y = 0; y < anim->y; y++) {
memcpy(&(ibuf->rect)[((anim->y - y) - 1) * anim->x], &tmp[y * anim->x],
anim->x * 4);
}
MEM_freeN(tmp);
}
ibuf->rect_colorspace = colormanage_colorspace_get_named(anim->colorspace);
return ibuf;
}
#endif /* WITH_AVI */
#ifdef WITH_FFMPEG
static int startffmpeg(struct anim *anim)
{
int i, videoStream;
AVCodec *pCodec;
AVFormatContext *pFormatCtx = NULL;
AVCodecContext *pCodecCtx;
int frs_num;
double frs_den;
int streamcount;
#ifdef FFMPEG_SWSCALE_COLOR_SPACE_SUPPORT
/* The following for color space determination */
int srcRange, dstRange, brightness, contrast, saturation;
int *table;
const int *inv_table;
#endif
if (anim == 0) return(-1);
streamcount = anim->streamindex;
if (avformat_open_input(&pFormatCtx, anim->name, NULL, NULL) != 0) {
return -1;
}
if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
av_close_input_file(pFormatCtx);
return -1;
}
av_dump_format(pFormatCtx, 0, anim->name, 0);
/* Find the video stream */
videoStream = -1;
for (i = 0; i < pFormatCtx->nb_streams; i++)
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
if (streamcount > 0) {
streamcount--;
continue;
}
videoStream = i;
break;
}
if (videoStream == -1) {
av_close_input_file(pFormatCtx);
return -1;
}
pCodecCtx = pFormatCtx->streams[videoStream]->codec;
/* Find the decoder for the video stream */
pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
if (pCodec == NULL) {
av_close_input_file(pFormatCtx);
return -1;
}
pCodecCtx->workaround_bugs = 1;
if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
av_close_input_file(pFormatCtx);
return -1;
}
anim->duration = ceil(pFormatCtx->duration *
av_q2d(pFormatCtx->streams[videoStream]->r_frame_rate) /
AV_TIME_BASE);
frs_num = pFormatCtx->streams[videoStream]->r_frame_rate.num;
frs_den = pFormatCtx->streams[videoStream]->r_frame_rate.den;
frs_den *= AV_TIME_BASE;
while (frs_num % 10 == 0 && frs_den >= 2.0 && frs_num > 10) {
frs_num /= 10;
frs_den /= 10;
}
anim->frs_sec = frs_num;
anim->frs_sec_base = frs_den;
anim->params = 0;
anim->x = pCodecCtx->width;
anim->y = av_get_cropped_height_from_codec(pCodecCtx);
anim->pFormatCtx = pFormatCtx;
anim->pCodecCtx = pCodecCtx;
anim->pCodec = pCodec;
anim->videoStream = videoStream;
anim->interlacing = 0;
anim->orientation = 0;
anim->framesize = anim->x * anim->y * 4;
anim->curposition = -1;
anim->last_frame = 0;
anim->last_pts = -1;
anim->next_pts = -1;
anim->next_packet.stream_index = -1;
anim->pFrame = avcodec_alloc_frame();
anim->pFrameComplete = FALSE;
anim->pFrameDeinterlaced = avcodec_alloc_frame();
anim->pFrameRGB = avcodec_alloc_frame();
if (avpicture_get_size(PIX_FMT_RGBA, anim->x, anim->y) !=
anim->x * anim->y * 4)
{
fprintf(stderr,
"ffmpeg has changed alloc scheme ... ARGHHH!\n");
avcodec_close(anim->pCodecCtx);
av_close_input_file(anim->pFormatCtx);
av_free(anim->pFrameRGB);
av_free(anim->pFrameDeinterlaced);
av_free(anim->pFrame);
anim->pCodecCtx = NULL;
return -1;
}
if (anim->ib_flags & IB_animdeinterlace) {
avpicture_fill((AVPicture *) anim->pFrameDeinterlaced,
MEM_callocN(avpicture_get_size(
anim->pCodecCtx->pix_fmt,
anim->pCodecCtx->width,
anim->pCodecCtx->height),
"ffmpeg deinterlace"),
anim->pCodecCtx->pix_fmt,
anim->pCodecCtx->width,
anim->pCodecCtx->height);
}
if (pCodecCtx->has_b_frames) {
anim->preseek = 25; /* FIXME: detect gopsize ... */
}
else {
anim->preseek = 0;
}
anim->img_convert_ctx = sws_getContext(
anim->x,
anim->y,
anim->pCodecCtx->pix_fmt,
anim->x,
anim->y,
PIX_FMT_RGBA,
SWS_FAST_BILINEAR | SWS_PRINT_INFO | SWS_FULL_CHR_H_INT,
NULL, NULL, NULL);
if (!anim->img_convert_ctx) {
fprintf(stderr,
"Can't transform color space??? Bailing out...\n");
avcodec_close(anim->pCodecCtx);
av_close_input_file(anim->pFormatCtx);
av_free(anim->pFrameRGB);
av_free(anim->pFrameDeinterlaced);
av_free(anim->pFrame);
anim->pCodecCtx = NULL;
return -1;
}
#ifdef FFMPEG_SWSCALE_COLOR_SPACE_SUPPORT
/* Try do detect if input has 0-255 YCbCR range (JFIF Jpeg MotionJpeg) */
if (!sws_getColorspaceDetails(anim->img_convert_ctx, (int **)&inv_table, &srcRange,
&table, &dstRange, &brightness, &contrast, &saturation))
{
srcRange = srcRange || anim->pCodecCtx->color_range == AVCOL_RANGE_JPEG;
inv_table = sws_getCoefficients(anim->pCodecCtx->colorspace);
if (sws_setColorspaceDetails(anim->img_convert_ctx, (int *)inv_table, srcRange,
table, dstRange, brightness, contrast, saturation))
{
fprintf(stderr, "Warning: Could not set libswscale colorspace details.\n");
}
}
else {
fprintf(stderr, "Warning: Could not set libswscale colorspace details.\n");
}
#endif
return (0);
}
static int merger(avi_t *out, char *file)
{
avi_t *in;
long frames, n, bytes;
int key, j, aud_tracks;
static int init = 0;
static int vid_chunks = 0;
double fps;
static double vid_ms;
static double aud_ms[AVI_MAX_TRACKS];
int have_printed=0;
int do_drop_video=0;
if (!init) {
for (j=0; j<AVI_MAX_TRACKS; j++)
aud_ms[j] = 0.0;
vid_ms = 0;
vid_chunks = 0;
init = 1;
}
if(indexfile) {
if (NULL == (in = AVI_open_input_indexfile(file, 0, indexfile))) {
AVI_print_error("AVI open with indexfile");
return(-1);
}
}
else if(NULL == (in = AVI_open_input_file(file,1))) {
AVI_print_error("AVI open");
return(-1);
}
AVI_seek_start(in);
fps = AVI_frame_rate(in);
frames = AVI_video_frames(in);
aud_tracks = AVI_audio_tracks(in);
for (n=0; n<frames; ++n) {
++vid_chunks;
vid_ms = vid_chunks*1000.0/fps;
// audio
for(j=0; j<aud_tracks; ++j) {
int ret;
double old_ms = aud_ms[j];
AVI_set_audio_track(in, j);
AVI_set_audio_track(out, j);
ret = sync_audio_video_avi2avi (vid_ms, &aud_ms[j], in, out);
if (ret<0) {
if (ret==-2) {
if (aud_ms[j] == old_ms) {
do_drop_video = 1;
if (!have_printed) {
fprintf(stderr, "\nNo audiodata left for track %d->%d (%.2f=%.2f) %s ..\n",
AVI_get_audio_track(in), AVI_get_audio_track(out),
old_ms, aud_ms[j], (do_drop_video && drop_video)?"breaking (-c)":"continuing");
have_printed++;
}
}
} else {
fprintf(stderr, "\nAn error happend at frame %ld track %d\n", n, j);
}
}
}
if (do_drop_video && drop_video) {
fprintf(stderr, "\n[avimerge] Dropping %ld frames\n", frames-n-1);
goto out;
}
// video
bytes = AVI_read_frame(in, data, &key);
if(bytes < 0) {
AVI_print_error("AVI read video frame");
return(-1);
}
if(AVI_write_frame(out, data, bytes, key)<0) {
AVI_print_error("AVI write video frame");
return(-1);
}
// progress
fprintf(stderr, "[%s] (%06ld-%06ld) (%.2f <-> %.2f)\r", file, sum_frames, sum_frames + n, vid_ms, aud_ms[0]);
}
out:
fprintf(stderr, "\n");
AVI_close(in);
sum_frames += n;
return(0);
}
int main(int argc, char *argv[])
{
avi_t *avifile, *avifile1, *avifile2;
char *outfile=NULL, *infile=NULL, *audfile=NULL;
long rate, mp3rate;
int j, ch, cc=0, track_num=0, out_track_num=-1;
int width, height, format=0, format_add, chan, bits, aud_error=0;
double fps;
char *codec;
long offset, frames, n, bytes, aud_offset=0;
int key;
int aud_tracks;
// for mp3 audio
FILE *f=NULL;
int len, headlen, chan_i, rate_i, mp3rate_i;
unsigned long vid_chunks=0;
char head[8];
off_t pos;
double aud_ms = 0.0, vid_ms = 0.0;
double aud_ms_w[AVI_MAX_TRACKS];
ac_init(AC_ALL);
if(argc==1) usage(EXIT_FAILURE);
while ((ch = getopt(argc, argv, "A:a:b:ci:o:p:f:x:?hv")) != -1) {
switch (ch) {
case 'i':
if(optarg[0]=='-') usage(EXIT_FAILURE);
infile = optarg;
break;
case 'A':
if(optarg[0]=='-') usage(EXIT_FAILURE);
out_track_num = atoi(optarg);
if(out_track_num<-1) usage(EXIT_FAILURE);
break;
case 'a':
if(optarg[0]=='-') usage(EXIT_FAILURE);
track_num = atoi(optarg);
if(track_num<0) usage(EXIT_FAILURE);
break;
case 'b':
if(optarg[0]=='-') usage(EXIT_FAILURE);
is_vbr = atoi(optarg);
if(is_vbr<0) usage(EXIT_FAILURE);
break;
case 'c':
drop_video = 1;
break;
case 'o':
if(optarg[0]=='-') usage(EXIT_FAILURE);
outfile = optarg;
break;
case 'p':
if(optarg[0]=='-') usage(EXIT_FAILURE);
audfile = optarg;
break;
case 'f':
if(optarg[0]=='-') usage(EXIT_FAILURE);
comfile = optarg;
break;
case 'x':
if(optarg[0]=='-') usage(EXIT_FAILURE);
indexfile = optarg;
break;
case 'v':
version();
exit(EXIT_SUCCESS);
case 'h':
usage(EXIT_SUCCESS);
default:
usage(EXIT_FAILURE);
}
}
if(outfile == NULL || infile == NULL) usage(EXIT_FAILURE);
printf("scanning file %s for video/audio parameter\n", infile);
// open first file for video/audio info read only
if(indexfile) {
if (NULL == (avifile1 = AVI_open_input_indexfile(infile,0,indexfile))) {
AVI_print_error("AVI open with index file");
}
}
else if(NULL == (avifile1 = AVI_open_input_file(infile,1))) {
AVI_print_error("AVI open");
exit(1);
}
AVI_info(avifile1);
// safety checks
if(strcmp(infile, outfile)==0) {
printf("error: output filename conflicts with input filename\n");
exit(1);
}
ch = optind;
while (ch < argc) {
if(tc_file_check(argv[ch]) != 0) {
printf("error: file not found\n");
exit(1);
}
if(strcmp(argv[ch++], outfile)==0) {
printf("error: output filename conflicts with input filename\n");
exit(1);
}
}
// open output file
if(NULL == (avifile = AVI_open_output_file(outfile))) {
AVI_print_error("AVI open");
exit(1);
}
// read video info;
width = AVI_video_width(avifile1);
height = AVI_video_height(avifile1);
fps = AVI_frame_rate(avifile1);
codec = AVI_video_compressor(avifile1);
//set video in outputfile
AVI_set_video(avifile, width, height, fps, codec);
if (comfile!=NULL)
AVI_set_comment_fd(avifile, open(comfile, O_RDONLY));
//multi audio tracks?
aud_tracks = AVI_audio_tracks(avifile1);
if (out_track_num < 0) out_track_num = aud_tracks;
for(j=0; j<aud_tracks; ++j) {
if (out_track_num == j) continue;
AVI_set_audio_track(avifile1, j);
rate = AVI_audio_rate(avifile1);
chan = AVI_audio_channels(avifile1);
bits = AVI_audio_bits(avifile1);
format = AVI_audio_format(avifile1);
mp3rate= AVI_audio_mp3rate(avifile1);
//printf("TRACK %d MP3RATE %ld VBR %ld\n", j, mp3rate, AVI_get_audio_vbr(avifile1));
//set next track of output file
AVI_set_audio_track(avifile, j);
AVI_set_audio(avifile, chan, rate, bits, format, mp3rate);
AVI_set_audio_vbr(avifile, AVI_get_audio_vbr(avifile1));
}
if(audfile!=NULL) goto audio_merge;
// close reopen in merger function
AVI_close(avifile1);
//-------------------------------------------------------------
printf("merging multiple AVI-files (concatenating) ...\n");
// extract and write to new files
printf ("file %02d %s\n", ++cc, infile);
merger(avifile, infile);
while (optind < argc) {
printf ("file %02d %s\n", ++cc, argv[optind]);
merger(avifile, argv[optind++]);
}
// close new AVI file
AVI_close(avifile);
printf("... done merging %d file(s) in %s\n", cc, outfile);
// reopen file for video/audio info
if(NULL == (avifile = AVI_open_input_file(outfile,1))) {
AVI_print_error("AVI open");
exit(1);
}
AVI_info(avifile);
return(0);
//-------------------------------------------------------------
// *************************************************
// Merge the audio track of an additional AVI file
// *************************************************
audio_merge:
printf("merging audio %s track %d (multiplexing) into %d ...\n", audfile, track_num, out_track_num);
// open audio file read only
if(NULL == (avifile2 = AVI_open_input_file(audfile,1))) {
int f=open(audfile, O_RDONLY), ret=0;
char head[1024], *c;
c = head;
if (f>0 && (1024 == read(f, head, 1024)) ) {
while ((c-head<1024-8) && (ret = tc_probe_audio_header(c, 8))<=0 ) {
c++;
}
close(f);
if (ret > 0) {
aud_offset = c-head;
//printf("found atrack 0x%x off=%ld\n", ret, aud_offset);
goto merge_mp3;
}
}
AVI_print_error("AVI open");
exit(1);
}
AVI_info(avifile2);
//switch to requested track
if(AVI_set_audio_track(avifile2, track_num)<0) {
fprintf(stderr, "invalid audio track\n");
}
rate = AVI_audio_rate(avifile2);
chan = AVI_audio_channels(avifile2);
bits = AVI_audio_bits(avifile2);
format = AVI_audio_format(avifile2);
mp3rate= AVI_audio_mp3rate(avifile2);
//set next track
AVI_set_audio_track(avifile, out_track_num);
AVI_set_audio(avifile, chan, rate, bits, format, mp3rate);
AVI_set_audio_vbr(avifile, AVI_get_audio_vbr(avifile2));
AVI_seek_start(avifile1);
frames = AVI_video_frames(avifile1);
offset = 0;
printf ("file %02d %s\n", ++cc, infile);
for (n=0; n<AVI_MAX_TRACKS; n++)
aud_ms_w[n] = 0.0;
vid_chunks=0;
for (n=0; n<frames; ++n) {
// video
bytes = AVI_read_frame(avifile1, data, &key);
if(bytes < 0) {
AVI_print_error("AVI read video frame");
return(-1);
}
if(AVI_write_frame(avifile, data, bytes, key)<0) {
AVI_print_error("AVI write video frame");
return(-1);
}
++vid_chunks;
vid_ms = vid_chunks*1000.0/fps;
for(j=0; j<aud_tracks; ++j) {
if (j == out_track_num) continue;
AVI_set_audio_track(avifile1, j);
AVI_set_audio_track(avifile, j);
chan = AVI_audio_channels(avifile1);
// audio
chan = AVI_audio_channels(avifile1);
if(chan) {
sync_audio_video_avi2avi(vid_ms, &aud_ms_w[j], avifile1, avifile);
}
}
// merge additional track
// audio
chan = AVI_audio_channels(avifile2);
AVI_set_audio_track(avifile, out_track_num);
if(chan) {
sync_audio_video_avi2avi(vid_ms, &aud_ms, avifile2, avifile);
}
// progress
fprintf(stderr, "[%s] (%06ld-%06ld)\r", outfile, offset, offset + n);
}
fprintf(stderr,"\n");
offset = frames;
//more files to merge?
AVI_close(avifile1);
while (optind < argc) {
printf ("file %02d %s\n", ++cc, argv[optind]);
if(NULL == ( avifile1 = AVI_open_input_file(argv[optind++],1))) {
AVI_print_error("AVI open");
goto finish;
}
AVI_seek_start(avifile1);
frames = AVI_video_frames(avifile1);
for (n=0; n<frames; ++n) {
// video
bytes = AVI_read_frame(avifile1, data, &key);
if(bytes < 0) {
AVI_print_error("AVI read video frame");
return(-1);
}
if(AVI_write_frame(avifile, data, bytes, key)<0) {
AVI_print_error("AVI write video frame");
return(-1);
}
++vid_chunks;
vid_ms = vid_chunks*1000.0/fps;
// audio
for(j=0; j<aud_tracks; ++j) {
if (j == out_track_num) continue;
AVI_set_audio_track(avifile1, j);
AVI_set_audio_track(avifile, j);
chan = AVI_audio_channels(avifile1);
if(chan) {
sync_audio_video_avi2avi(vid_ms, &aud_ms_w[j], avifile1, avifile);
}
}
// merge additional track
chan = AVI_audio_channels(avifile2);
AVI_set_audio_track(avifile, out_track_num);
if(chan) {
sync_audio_video_avi2avi(vid_ms, &aud_ms, avifile2, avifile);
} // chan
// progress
fprintf(stderr, "[%s] (%06ld-%06ld)\r", outfile, offset, offset + n);
}
fprintf(stderr, "\n");
offset += frames;
AVI_close(avifile1);
}
finish:
// close new AVI file
printf("... done multiplexing in %s\n", outfile);
AVI_info(avifile);
AVI_close(avifile);
return(0);
// *************************************************
// Merge a raw audio file which is either MP3 or AC3
// *************************************************
merge_mp3:
f = fopen(audfile,"rb");
if (!f) { perror ("fopen"); exit(1); }
fseek(f, aud_offset, SEEK_SET);
len = fread(head, 1, 8, f);
format_add = tc_probe_audio_header(head, len);
headlen = tc_get_audio_header(head, len, format_add, &chan_i, &rate_i, &mp3rate_i);
fprintf(stderr, "... this looks like a %s track ...\n", (format_add==0x55)?"MP3":"AC3");
fseek(f, aud_offset, SEEK_SET);
//set next track
AVI_set_audio_track(avifile, out_track_num);
AVI_set_audio(avifile, chan_i, rate_i, 16, format_add, mp3rate_i);
AVI_set_audio_vbr(avifile, is_vbr);
AVI_seek_start(avifile1);
frames = AVI_video_frames(avifile1);
offset = 0;
for (n=0; n<AVI_MAX_TRACKS; ++n)
aud_ms_w[n] = 0.0;
for (n=0; n<frames; ++n) {
// video
bytes = AVI_read_frame(avifile1, data, &key);
if(bytes < 0) {
AVI_print_error("AVI read video frame");
return(-1);
}
if(AVI_write_frame(avifile, data, bytes, key)<0) {
AVI_print_error("AVI write video frame");
return(-1);
}
vid_chunks++;
vid_ms = vid_chunks*1000.0/fps;
for(j=0; j<aud_tracks; ++j) {
if (j == out_track_num) continue;
AVI_set_audio_track(avifile1, j);
AVI_set_audio_track(avifile, j);
chan = AVI_audio_channels(avifile1);
if(chan) {
sync_audio_video_avi2avi(vid_ms, &aud_ms_w[j], avifile1, avifile);
}
}
// merge additional track
if(headlen>4 && !aud_error) {
while (aud_ms < vid_ms) {
//printf("reading Audio Chunk ch(%ld) vms(%lf) ams(%lf)\n", vid_chunks, vid_ms, aud_ms);
pos = ftell(f);
len = fread (head, 1, 8, f);
if (len<=0) { //eof
fprintf(stderr, "EOF in %s; continuing ..\n", audfile);
aud_error=1;
break;
}
if ( (headlen = tc_get_audio_header(head, len, format_add, NULL, NULL, &mp3rate_i))<0) {
fprintf(stderr, "Broken %s track #(%d)? skipping\n", (format_add==0x55?"MP3":"AC3"), aud_tracks);
aud_ms = vid_ms;
aud_error=1;
} else { // look in import/tcscan.c for explanation
aud_ms += (headlen*8.0)/(mp3rate_i);
}
fseek (f, pos, SEEK_SET);
len = fread (data, headlen, 1, f);
if (len<=0) { //eof
fprintf(stderr, "EOF in %s; continuing ..\n", audfile);
aud_error=1;
break;
}
AVI_set_audio_track(avifile, out_track_num);
if(AVI_write_audio(avifile, data, headlen)<0) {
AVI_print_error("AVI write audio frame");
return(-1);
}
}
}
// progress
fprintf(stderr, "[%s] (%06ld-%06ld)\r", outfile, offset, offset + n);
}
fprintf(stderr,"\n");
offset = frames;
// more files?
while (optind < argc) {
printf ("file %02d %s\n", ++cc, argv[optind]);
if(NULL == ( avifile1 = AVI_open_input_file(argv[optind++],1))) {
AVI_print_error("AVI open");
goto finish;
}
AVI_seek_start(avifile1);
frames = AVI_video_frames(avifile1);
for (n=0; n<frames; ++n) {
// video
bytes = AVI_read_frame(avifile1, data, &key);
if(bytes < 0) {
AVI_print_error("AVI read video frame");
return(-1);
}
if(AVI_write_frame(avifile, data, bytes, key)<0) {
AVI_print_error("AVI write video frame");
return(-1);
}
vid_chunks++;
vid_ms = vid_chunks*1000.0/fps;
for(j=0; j<aud_tracks; ++j) {
if (j == out_track_num) continue;
AVI_set_audio_track(avifile1, j);
AVI_set_audio_track(avifile, j);
chan = AVI_audio_channels(avifile1);
if(chan) {
sync_audio_video_avi2avi(vid_ms, &aud_ms_w[j], avifile1, avifile);
}
}
// merge additional track
// audio
if(headlen>4 && !aud_error) {
while (aud_ms < vid_ms) {
//printf("reading Audio Chunk ch(%ld) vms(%lf) ams(%lf)\n", vid_chunks, vid_ms, aud_ms);
pos = ftell(f);
len = fread (head, 8, 1, f);
if (len<=0) { //eof
fprintf(stderr, "EOF in %s; continuing ..\n", audfile);
aud_error=1; break;
}
if ( (headlen = tc_get_audio_header(head, len, format_add, NULL, NULL, &mp3rate_i))<0) {
fprintf(stderr, "Broken %s track #(%d)?\n", (format_add==0x55?"MP3":"AC3"), aud_tracks);
aud_ms = vid_ms;
aud_error=1;
} else { // look in import/tcscan.c for explanation
aud_ms += (headlen*8.0)/(mp3rate_i);
}
fseek (f, pos, SEEK_SET);
len = fread (data, headlen, 1, f);
if (len<=0) { //eof
fprintf(stderr, "EOF in %s; continuing ..\n", audfile);
aud_error=1; break;
}
AVI_set_audio_track(avifile, out_track_num);
if(AVI_write_audio(avifile, data, headlen)<0) {
AVI_print_error("AVI write audio frame");
return(-1);
}
}
}
// progress
fprintf(stderr, "[%s] (%06ld-%06ld)\r", outfile, offset, offset + n);
}
fprintf(stderr, "\n");
offset += frames;
AVI_close(avifile1);
}
if (f) fclose(f);
printf("... done multiplexing in %s\n", outfile);
AVI_close(avifile);
return(0);
}
