jlong Java_com_mcxiaoke_ndk_Native_open(
JNIEnv* env,
jclass clazz,
jstring fileName)
{
avi_t* avi = 0;
// Get the file name as a C string
const char* cFileName = env->GetStringUTFChars(fileName, 0);
if (0 == cFileName)
{
goto exit;
}
// Open the AVI file
avi = AVI_open_input_file(cFileName, 1);
// Release the file name
env->ReleaseStringUTFChars(fileName, cFileName);
// If AVI file cannot be opened throw an exception
if (0 == avi)
{
ThrowException(env, "java/io/IOException", AVI_strerror());
}
exit:
return (jlong) avi;
}
int evid_destroy_handler(evid_handler_t *evid_handler, char **errstr) {
handler_t *handler=(handler_t *)evid_handler;
free(handler->filename);
// avilib
if(AVI_close(handler->avilib.avi)) {
x_asprintf(errstr, "Error closing AVI file: %s.\n", AVI_strerror());
return 1;
}
// xvid
if(xvid_encore(handler->xvid.handle, XVID_ENC_DESTROY, NULL, NULL)) {
(*errstr)=NULL;
return 1;
}
// free bitstream
free(handler->xvid.bitstream);
// free handle
free(handler);
return 0;
}
void
avi_reader_c::add_audio_demuxer(int aid) {
for (auto &demuxer : m_audio_demuxers)
if (demuxer.m_aid == aid) // Demuxer already added?
return;
AVI_set_audio_track(m_avi, aid);
if (AVI_read_audio_chunk(m_avi, nullptr) < 0) {
mxwarn(boost::format(Y("Could not find an index for audio track %1% (avilib error message: %2%). Skipping track.\n")) % (aid + 1) % AVI_strerror());
return;
}
avi_demuxer_t demuxer;
generic_packetizer_c *packetizer = nullptr;
alWAVEFORMATEX *wfe = m_avi->wave_format_ex[aid];
uint32_t audio_format = AVI_audio_format(m_avi);
demuxer.m_aid = aid;
demuxer.m_ptzr = -1;
demuxer.m_samples_per_second = AVI_audio_rate(m_avi);
demuxer.m_channels = AVI_audio_channels(m_avi);
demuxer.m_bits_per_sample = AVI_audio_bits(m_avi);
m_ti.m_id = aid + 1; // ID for this audio track.
m_ti.m_avi_block_align = get_uint16_le(&wfe->n_block_align);
m_ti.m_avi_avg_bytes_per_sec = get_uint32_le(&wfe->n_avg_bytes_per_sec);
m_ti.m_avi_samples_per_chunk = get_uint32_le(&m_avi->stream_headers[aid].dw_scale);
m_ti.m_avi_sample_scale = get_uint32_le(&m_avi->stream_headers[aid].dw_rate);
m_ti.m_avi_samples_per_sec = demuxer.m_samples_per_second;
if ((0xfffe == audio_format) && (get_uint16_le(&wfe->cb_size) >= (sizeof(alWAVEFORMATEXTENSION)))) {
alWAVEFORMATEXTENSIBLE *ext = reinterpret_cast<alWAVEFORMATEXTENSIBLE *>(wfe);
audio_format = get_uint32_le(&ext->extension.guid.data1);
} else if (get_uint16_le(&wfe->cb_size) > 0)
m_ti.m_private_data = memory_c::clone(wfe + 1, get_uint16_le(&wfe->cb_size));
else
m_ti.m_private_data.reset();
switch(audio_format) {
case 0x0001: // raw PCM audio
case 0x0003: // raw PCM audio (float)
packetizer = new pcm_packetizer_c(this, m_ti, demuxer.m_samples_per_second, demuxer.m_channels, demuxer.m_bits_per_sample, 0x0003 == audio_format ? pcm_packetizer_c::ieee_float : pcm_packetizer_c::little_endian_integer);
break;
case 0x0050: // MP2
case 0x0055: // MP3
packetizer = new mp3_packetizer_c(this, m_ti, demuxer.m_samples_per_second, demuxer.m_channels, false);
break;
case 0x2000: // AC3
packetizer = new ac3_packetizer_c(this, m_ti, demuxer.m_samples_per_second, demuxer.m_channels, 0);
break;
case 0x2001: // DTS
packetizer = create_dts_packetizer(aid);
break;
case 0x00ff:
case 0x706d: // AAC
packetizer = create_aac_packetizer(aid, demuxer);
break;
case 0x566f: // Vorbis
packetizer = create_vorbis_packetizer(aid);
break;
default:
mxerror_tid(m_ti.m_fname, aid + 1, boost::format(Y("Unknown/unsupported audio format 0x%|1$04x| for this audio track.\n")) % audio_format);
}
show_packetizer_info(aid + 1, packetizer);
demuxer.m_ptzr = add_packetizer(packetizer);
m_audio_demuxers.push_back(demuxer);
int i, maxchunks = AVI_audio_chunks(m_avi);
for (i = 0; i < maxchunks; i++)
m_bytes_to_process += AVI_audio_size(m_avi, i);
}
/*
* 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);
}
/*
* Create the media for the quicktime file, and set up some session stuff.
*/
int create_media_for_avi_file (CPlayerSession *psptr,
const char *name,
char *errmsg,
uint32_t errlen,
int have_audio_driver,
control_callback_vft_t *cc_vft)
{
CAviFile *Avifile1 = NULL;
avi_t *avi;
CPlayerMedia *mptr;
avi = AVI_open_input_file(name, 1);
if (avi == NULL) {
snprintf(errmsg, errlen, "%s", AVI_strerror());
player_error_message("%s", AVI_strerror());
return (-1);
}
int video_count = 1;
codec_plugin_t *plugin;
video_query_t vq;
const char *codec_name = AVI_video_compressor(avi);
player_debug_message("Trying avi video codec %s", codec_name);
plugin = check_for_video_codec(STREAM_TYPE_AVI_FILE,
codec_name,
NULL,
-1,
-1,
NULL,
0,
&config);
if (plugin == NULL) {
video_count = 0;
} else {
vq.track_id = 1;
vq.stream_type = STREAM_TYPE_AVI_FILE;
vq.compressor = codec_name;
vq.type = -1;
vq.profile = -1;
vq.fptr = NULL;
vq.h = AVI_video_height(avi);
vq.w = AVI_video_width(avi);
vq.frame_rate = AVI_video_frame_rate(avi);
vq.config = NULL;
vq.config_len = 0;
vq.enabled = 0;
vq.reference = NULL;
}
int have_audio = 0;
int audio_count = 0;
audio_query_t aq;
if (AVI_audio_bytes(avi) != 0) {
have_audio = 1;
plugin = check_for_audio_codec(STREAM_TYPE_AVI_FILE,
NULL,
NULL,
AVI_audio_format(avi),
-1,
NULL,
0,
&config);
if (plugin != NULL) {
audio_count = 1;
aq.track_id = 1;
aq.stream_type = STREAM_TYPE_AVI_FILE;
aq.compressor = NULL;
aq.type = AVI_audio_format(avi);
aq.profile = -1;
aq.fptr = NULL;
aq.sampling_freq = AVI_audio_rate(avi);
aq.chans = AVI_audio_channels(avi);
aq.config = NULL;
aq.config_len = 0;
aq.enabled = 0;
aq.reference = NULL;
}
}
if (cc_vft != NULL && cc_vft->media_list_query != NULL) {
(cc_vft->media_list_query)(psptr, video_count, &vq, audio_count, &aq);
} else {
if (video_count != 0) vq.enabled = 1;
if (audio_count != 0) aq.enabled = 1;
}
if ((video_count == 0 || vq.enabled == 0) &&
(audio_count == 0 || aq.enabled == 0)) {
snprintf(errmsg, errlen, "No audio or video tracks enabled or playable");
AVI_close(avi);
return -1;
}
Avifile1 = new CAviFile(name, avi, vq.enabled, audio_count);
psptr->set_media_close_callback(close_avi_file, Avifile1);
if (video_count != 0 && vq.enabled) {
mptr = new CPlayerMedia(psptr);
if (mptr == NULL) {
return (-1);
}
video_info_t *vinfo = MALLOC_STRUCTURE(video_info_t);
if (vinfo == NULL)
return (-1);
vinfo->height = vq.h;
vinfo->width = vq.w;
player_debug_message("avi file h %d w %d frame rate %g",
vinfo->height,
vinfo->width,
vq.frame_rate);
plugin = check_for_video_codec(STREAM_TYPE_AVI_FILE,
codec_name,
NULL,
-1,
-1,
NULL,
0,
&config);
int ret;
ret = mptr->create_video_plugin(plugin,
STREAM_TYPE_AVI_FILE,
codec_name,
-1,
-1,
NULL,
vinfo,
NULL,
0);
if (ret < 0) {
snprintf(errmsg, errlen, "Failed to create video plugin %s",
codec_name);
player_error_message("Failed to create plugin data");
delete mptr;
return -1;
}
CAviVideoByteStream *vbyte = new CAviVideoByteStream(Avifile1);
if (vbyte == NULL) {
delete mptr;
return (-1);
}
vbyte->config(AVI_video_frames(avi), vq.frame_rate);
ret = mptr->create(vbyte, TRUE, errmsg, errlen);
if (ret != 0) {
return (-1);
}
}
int seekable = 1;
if (have_audio_driver > 0 && audio_count > 0 && aq.enabled != 0) {
plugin = check_for_audio_codec(STREAM_TYPE_AVI_FILE,
NULL,
NULL,
aq.type,
-1,
NULL,
0,
&config);
CAviAudioByteStream *abyte;
mptr = new CPlayerMedia(psptr);
if (mptr == NULL) {
return (-1);
}
audio_info_t *ainfo;
ainfo = MALLOC_STRUCTURE(audio_info_t);
ainfo->freq = aq.sampling_freq;
ainfo->chans = aq.chans;
ainfo->bitspersample = AVI_audio_bits(avi);
int ret;
ret = mptr->create_audio_plugin(plugin,
aq.stream_type,
aq.compressor,
aq.type,
aq.profile,
NULL,
ainfo,
NULL,
0);
if (ret < 0) {
delete mptr;
player_error_message("Couldn't create audio from plugin %s",
plugin->c_name);
return -1;
}
abyte = new CAviAudioByteStream(Avifile1);
ret = mptr->create(abyte, FALSE, errmsg, errlen);
if (ret != 0) {
return (-1);
}
seekable = 0;
}
psptr->session_set_seekable(seekable);
if (audio_count == 0 && have_audio != 0) {
snprintf(errmsg, errlen, "Unknown Audio Codec in avi file ");
return (1);
}
if (video_count != 1) {
snprintf(errmsg, errlen, "Unknown Video Codec %s in avi file",
codec_name);
return (1);
}
return (0);
}
evid_handler_t *evid_create_handler(frame_par_t *frame_par, evid_xvidpar_t *evid_xvidpar, double framerate, char *filename, char **errstr) {
xvid_enc_create_t xvid_enc_create;
handler_t *handler;
handler=(handler_t *)x_malloc(sizeof(handler_t));
// frame_par
memcpy(&(handler->frame_par), frame_par, sizeof(frame_par_t));
// xvid_par
memcpy(&(handler->evid_xvidpar), evid_xvidpar, sizeof(evid_xvidpar_t));
// sets file name
handler->filename=(char *)x_malloc(strlen(filename)+1);
strcpy(handler->filename, filename);
// avilib
if((handler->avilib.avi=AVI_open_output_file(filename))==NULL) {
x_asprintf(errstr, "%s.\n", AVI_strerror());
free(handler);
return NULL;
}
AVI_set_video(handler->avilib.avi, frame_par->width, frame_par->height, framerate, "xvid");
AVI_set_audio(handler->avilib.avi, 0, 44100, 16, WAVE_FORMAT_UNKNOWN);
// xvid encoder
memset(&xvid_enc_create, 0, sizeof(xvid_enc_create));
xvid_enc_create.profile=XVID_PROFILE_S_L0; // XVID_PROFILE_AS_L4; // do not know abot this...
xvid_enc_create.version=XVID_VERSION;
xvid_enc_create.width=frame_par->width;
xvid_enc_create.height=frame_par->height;
xvid_enc_create.num_zones=0;
xvid_enc_create.zones=NULL;
xvid_enc_create.num_plugins=0;
xvid_enc_create.plugins=NULL;
xvid_enc_create.num_threads=0;
xvid_enc_create.max_bframes=0;
xvid_enc_create.global=0;
xvid_enc_create.global|=XVID_GLOBAL_CLOSED_GOP;
xvid_enc_create.fincr=1000;
xvid_enc_create.fbase=(int)(framerate*1000);
xvid_enc_create.max_key_interval=(int)(framerate*10);
xvid_enc_create.frame_drop_ratio=0;
xvid_enc_create.bquant_ratio=150;
xvid_enc_create.bquant_offset=100;
xvid_enc_create.min_quant[0]=2;
xvid_enc_create.max_quant[0]=31;
if(xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL)) {
x_asprintf(errstr, "Error initializing XviD encore.\n");
if(AVI_close(handler->avilib.avi)) {
free((*errstr));
x_asprintf(errstr, "Error initializing XviD encore / Error closing AVI file: %s.\n", AVI_strerror());
}
unlink(filename); // no error checking here
free(handler);
return NULL;
}
handler->xvid.handle=xvid_enc_create.handle;
// bitstream
handler->xvid.bitstream=x_malloc((size_t)(handler->frame_par.width*handler->frame_par.height*PALETTE_DEPTH));
// errstr
handler->errstr=NULL;
return (evid_handler_t *)handler;
}
int evid_enc_frame(evid_handler_t *evid_handler, pixel_t *frame) {
xvid_enc_frame_t xvid_enc_frame;
handler_t *handler=(handler_t *)evid_handler;
static const int vop_presets[] = {
0,
0,
XVID_VOP_HALFPEL,
XVID_VOP_HALFPEL | XVID_VOP_INTER4V,
XVID_VOP_HALFPEL | XVID_VOP_INTER4V,
XVID_VOP_HALFPEL | XVID_VOP_INTER4V | XVID_VOP_TRELLISQUANT,
XVID_VOP_HALFPEL | XVID_VOP_INTER4V | XVID_VOP_TRELLISQUANT | XVID_VOP_HQACPRED,
};
static const int motion_presets[] = {
0,
XVID_ME_ADVANCEDDIAMOND16,
XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16,
XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16 | XVID_ME_ADVANCEDDIAMOND8 | XVID_ME_HALFPELREFINE8,
XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16 | XVID_ME_ADVANCEDDIAMOND8 | XVID_ME_HALFPELREFINE8 | XVID_ME_CHROMA_PVOP | XVID_ME_CHROMA_BVOP,
XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16 | XVID_ME_ADVANCEDDIAMOND8 | XVID_ME_HALFPELREFINE8 | XVID_ME_CHROMA_PVOP | XVID_ME_CHROMA_BVOP,
XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16 | XVID_ME_EXTSEARCH16 | XVID_ME_ADVANCEDDIAMOND8 | XVID_ME_HALFPELREFINE8 | XVID_ME_EXTSEARCH8 | XVID_ME_CHROMA_PVOP | XVID_ME_CHROMA_BVOP,
};
int frame_size;
// XviD
memset(&xvid_enc_frame, 0, sizeof(xvid_enc_frame));
xvid_enc_frame.version=XVID_VERSION;
xvid_enc_frame.vol_flags=0;
xvid_enc_frame.vol_flags|=XVID_VOL_INTERLACING;
xvid_enc_frame.quant_intra_matrix=NULL;
xvid_enc_frame.quant_inter_matrix=NULL;
xvid_enc_frame.par=XVID_PAR_11_VGA;
xvid_enc_frame.par_width=1;
xvid_enc_frame.par_height=1;
xvid_enc_frame.fincr=0;
xvid_enc_frame.vop_flags=vop_presets[handler->evid_xvidpar.quality];
if(handler->evid_xvidpar.gray)
xvid_enc_frame.vop_flags|=XVID_VOP_GREYSCALE;
xvid_enc_frame.motion=motion_presets[handler->evid_xvidpar.quality];
xvid_enc_frame.input.csp=XVID_CSP_YUY2;
xvid_enc_frame.input.plane[0]=frame;
xvid_enc_frame.input.stride[0]=handler->frame_par.width*PALETTE_DEPTH;
xvid_enc_frame.type=XVID_TYPE_AUTO;
xvid_enc_frame.quant=handler->evid_xvidpar.quant;
xvid_enc_frame.bitstream=handler->xvid.bitstream;
xvid_enc_frame.length=-1;
frame_size=xvid_encore(handler->xvid.handle, XVID_ENC_ENCODE, &xvid_enc_frame, NULL);
// avilib
if(AVI_write_frame(handler->avilib.avi, (char *)handler->xvid.bitstream, (long)frame_size, ((xvid_enc_frame.out_flags&XVID_KEYFRAME)?1:0))) {
free(handler->errstr);
switch(AVI_errno) {
case AVI_ERR_SIZELIM:
return 1;
break;
default:
x_asprintf(&handler->errstr, "Error writing encoded frame to AVI file: %s.\n", AVI_strerror());
break;
}
return 1;
}
// update header
if(AVI_make_header(handler->avilib.avi)) {
free(handler->errstr);
x_asprintf(&handler->errstr, "Error writing encoded frame to AVI file: %s.\n", AVI_strerror());
return 1;
}
return 0;
}
void
avi_reader_c::add_audio_demuxer(int aid) {
for (auto &demuxer : m_audio_demuxers)
if (demuxer.m_aid == aid) // Demuxer already added?
return;
AVI_set_audio_track(m_avi, aid);
if (AVI_read_audio_chunk(m_avi, nullptr) < 0) {
mxwarn(boost::format(Y("Could not find an index for audio track %1% (avilib error message: %2%). Skipping track.\n")) % (aid + 1) % AVI_strerror());
return;
}
avi_demuxer_t demuxer;
generic_packetizer_c *packetizer = nullptr;
alWAVEFORMATEX *wfe = m_avi->wave_format_ex[aid];
uint32_t audio_format = AVI_audio_format(m_avi);
demuxer.m_aid = aid;
demuxer.m_ptzr = -1;
demuxer.m_samples_per_second = AVI_audio_rate(m_avi);
demuxer.m_channels = AVI_audio_channels(m_avi);
demuxer.m_bits_per_sample = AVI_audio_bits(m_avi);
m_ti.m_id = aid + 1; // ID for this audio track.
auto stream_header = &m_avi->stream_headers[aid];
auto dw_scale = static_cast<int64_t>(get_uint32_le(&stream_header->dw_scale));
auto dw_rate = static_cast<int64_t>(get_uint32_le(&stream_header->dw_rate));
auto dw_sample_size = static_cast<int64_t>(get_uint32_le(&stream_header->dw_sample_size));
m_ti.m_avi_audio_data_rate = dw_scale ? dw_rate * dw_sample_size / dw_scale : 0;
if ((0xfffe == audio_format) && (get_uint16_le(&wfe->cb_size) >= (sizeof(alWAVEFORMATEXTENSION)))) {
alWAVEFORMATEXTENSIBLE *ext = reinterpret_cast<alWAVEFORMATEXTENSIBLE *>(wfe);
audio_format = get_uint32_le(&ext->extension.guid.data1);
} else if (get_uint16_le(&wfe->cb_size) > 0)
m_ti.m_private_data = memory_c::clone(wfe + 1, get_uint16_le(&wfe->cb_size));
else
m_ti.m_private_data.reset();
demuxer.m_codec = codec_c::look_up_audio_format(audio_format);
if (demuxer.m_codec.is(codec_c::type_e::A_PCM))
packetizer = new pcm_packetizer_c(this, m_ti, demuxer.m_samples_per_second, demuxer.m_channels, demuxer.m_bits_per_sample, 0x0003 == audio_format ? pcm_packetizer_c::ieee_float : pcm_packetizer_c::little_endian_integer);
else if (demuxer.m_codec.is(codec_c::type_e::A_MP2) || demuxer.m_codec.is(codec_c::type_e::A_MP3))
packetizer = new mp3_packetizer_c(this, m_ti, demuxer.m_samples_per_second, demuxer.m_channels, false);
else if (demuxer.m_codec.is(codec_c::type_e::A_AC3))
packetizer = new ac3_packetizer_c(this, m_ti, demuxer.m_samples_per_second, demuxer.m_channels, 0);
else if (demuxer.m_codec.is(codec_c::type_e::A_DTS))
packetizer = create_dts_packetizer(aid);
else if (demuxer.m_codec.is(codec_c::type_e::A_AAC))
packetizer = create_aac_packetizer(aid, demuxer);
else if (demuxer.m_codec.is(codec_c::type_e::A_VORBIS))
packetizer = create_vorbis_packetizer(aid);
else
mxerror_tid(m_ti.m_fname, aid + 1, boost::format(Y("Unknown/unsupported audio format 0x%|1$04x| for this audio track.\n")) % audio_format);
packetizer->enable_avi_audio_sync(true);
show_packetizer_info(aid + 1, packetizer);
demuxer.m_ptzr = add_packetizer(packetizer);
m_audio_demuxers.push_back(demuxer);
int i, maxchunks = AVI_audio_chunks(m_avi);
for (i = 0; i < maxchunks; i++) {
auto size = AVI_audio_size(m_avi, i);
if (size < AVI_MAX_AUDIO_CHUNK_SIZE)
m_bytes_to_process += size;
}
}
