static void calc_timecode(int pos, int do_frames)
{
MPEG_timecode_t tc;
mpeg_timecode(&tc, pos,
mpeg_framerate_code(mpeg_conform_framerate(fps)), fps);
if (!do_frames) tc.f=0;
sprintf(timecode,"%2d:%2.2d:%2.2d:%2.2d",tc.h,tc.m,tc.s,tc.f);
}
static char *print_status(int frame, double framerate) {
MPEG_timecode_t tc;
static char temp[256];
mpeg_timecode(&tc, frame,
mpeg_framerate_code(mpeg_conform_framerate(framerate)),
framerate);
sprintf(temp, "%d:%2.2d:%2.2d.%2.2d", tc.h, tc.m, tc.s, tc.f);
return temp;
}
char *format_time(int pos, double fps)
{
char temp[128];
MPEG_timecode_t tc;
y4m_ratio_t r = mpeg_conform_framerate(fps);
mpeg_timecode(&tc,
pos,
mpeg_framerate_code(r),
fps );
snprintf(temp,sizeof(temp),"%d:%2.2d:%2.2d:%2.2d",tc.h, tc.m, tc.s, tc.f );
return strdup(temp);
}
static void stats(video_playback_stats *stats)
{
if (exit_flag) return;
current_frame = stats->frame;
if (gui_mode)
{
printf("@%g/%d/%ld/%d\n",info->editlist->video_fps,stats->frame,
info->editlist->video_frames,stats->play_speed);
}
else
{
MPEG_timecode_t tc;
mpeg_timecode(&tc, stats->frame, mpeg_framerate_code
(mpeg_conform_framerate(info->editlist->video_fps)),
info->editlist->video_fps);
printf("%d:%2.2d:%2.2d.%2.2d (%6.6d/%6.6ld) - Speed: %c%d, Norm: %s, Diff: %f\r",
tc.h, tc.m, tc.s, tc.f, stats->frame, info->editlist->video_frames,
stats->play_speed>0?'+':(stats->play_speed<0?'-':' '), abs(stats->play_speed),
stats->norm==1?"NTSC":"PAL", stats->tdiff);
}
fflush(stdout);
}
static int tc_y4m_open_video(Y4MPrivateData *pd, const char *filename,
vob_t *vob)
{
int asr, ret;
y4m_ratio_t framerate;
y4m_ratio_t asr_rate;
/* avoid fd loss in case of failed configuration */
if (pd->fd_vid == -1) {
pd->fd_vid = open(filename,
O_RDWR|O_CREAT|O_TRUNC,
S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
if (pd->fd_vid == -1) {
tc_log_error(MOD_NAME, "failed to open video stream file '%s'"
" (reason: %s)", filename,
strerror(errno));
return TC_ERROR;
}
}
y4m_init_stream_info(&(pd->streaminfo));
//note: this is the real framerate of the raw stream
framerate = (vob->ex_frc == 0) ?mpeg_conform_framerate(vob->ex_fps)
:mpeg_framerate(vob->ex_frc);
if (framerate.n == 0 && framerate.d == 0) {
framerate.n = vob->ex_fps * 1000;
framerate.d = 1000;
}
asr = (vob->ex_asr < 0) ?vob->im_asr :vob->ex_asr;
tc_asr_code_to_ratio(asr, &asr_rate.n, &asr_rate.d);
y4m_init_stream_info(&(pd->streaminfo));
y4m_si_set_framerate(&(pd->streaminfo), framerate);
if (vob->encode_fields == TC_ENCODE_FIELDS_TOP_FIRST) {
y4m_si_set_interlace(&(pd->streaminfo), Y4M_ILACE_TOP_FIRST);
} else if (vob->encode_fields == TC_ENCODE_FIELDS_BOTTOM_FIRST) {
y4m_si_set_interlace(&(pd->streaminfo), Y4M_ILACE_BOTTOM_FIRST);
} else if (vob->encode_fields == TC_ENCODE_FIELDS_PROGRESSIVE) {
y4m_si_set_interlace(&(pd->streaminfo), Y4M_ILACE_NONE);
}
/* XXX */
y4m_si_set_sampleaspect(&(pd->streaminfo),
y4m_guess_sar(pd->width,
pd->height,
asr_rate));
y4m_si_set_height(&(pd->streaminfo), pd->height);
y4m_si_set_width(&(pd->streaminfo), pd->width);
/* Y4M_CHROMA_420JPEG 4:2:0, H/V centered, for JPEG/MPEG-1 */
/* Y4M_CHROMA_420MPEG2 4:2:0, H cosited, for MPEG-2 */
/* Y4M_CHROMA_420PALDV 4:2:0, alternating Cb/Cr, for PAL-DV */
y4m_si_set_chroma(&(pd->streaminfo), Y4M_CHROMA_420JPEG); // XXX
ret = y4m_write_stream_header(pd->fd_vid, &(pd->streaminfo));
if (ret != Y4M_OK) {
tc_log_warn(MOD_NAME, "failed to write video YUV4MPEG2 header: %s",
y4m_strerr(ret));
return TC_ERROR;
}
return TC_OK;
}
void writeoutYUV4MPEGheader(int out_fd,
LavParam *param,
EditList el,
y4m_stream_info_t *streaminfo)
{
int n;
y4m_si_set_width(streaminfo, param->output_width);
y4m_si_set_height(streaminfo, param->output_height);
y4m_si_set_interlace(streaminfo, param->interlace);
y4m_si_set_framerate(streaminfo, mpeg_conform_framerate(el.video_fps));
if (!Y4M_RATIO_EQL(param->sar, y4m_sar_UNKNOWN)) {
y4m_si_set_sampleaspect(streaminfo, param->sar);
} else if ((el.video_sar_width != 0) || (el.video_sar_height != 0)) {
y4m_ratio_t sar;
sar.n = el.video_sar_width;
sar.d = el.video_sar_height;
y4m_si_set_sampleaspect(streaminfo, sar);
} else {
/* no idea! ...eh, just guess. */
mjpeg_warn("unspecified sample-aspect-ratio --- taking a guess...");
y4m_si_set_sampleaspect(streaminfo,
y4m_guess_sar(param->output_width,
param->output_height,
param->dar));
}
switch (el_video_frame_data_format(0, &el)) { /* FIXME: checking only 0-th frame. */
case DATAFORMAT_YUV420:
switch (param->chroma) {
case Y4M_UNKNOWN:
case Y4M_CHROMA_420JPEG:
break;
case Y4M_CHROMA_420MPEG2:
case Y4M_CHROMA_420PALDV:
mjpeg_warn("4:2:0 chroma should be '420jpeg' with this input");
break;
default:
mjpeg_error_exit1("must specify 4:2:0 chroma (should be '420jpeg') with this input");
break;
}
break;
case DATAFORMAT_YUV422:
switch (param->chroma) {
case Y4M_CHROMA_422:
break;
default:
mjpeg_error_exit1("must specify chroma '422' with this input");
break;
}
break;
case DATAFORMAT_DV2:
#ifndef HAVE_LIBDV
mjpeg_error_exit1("DV input was not configured at compile time");
#else
el_get_video_frame(jpeg_data, 0, &el); /* FIXME: checking only 0-th frame. */
dv_parse_header(decoder, jpeg_data);
switch(decoder->sampling) {
case e_dv_sample_420:
switch (param->chroma) {
case Y4M_UNKNOWN:
mjpeg_info("set chroma '420paldv' from input");
param->chroma = Y4M_CHROMA_420PALDV;
break;
case Y4M_CHROMA_420PALDV:
break;
case Y4M_CHROMA_420JPEG:
case Y4M_CHROMA_420MPEG2:
mjpeg_warn("4:2:0 chroma should be '420paldv' with this input");
break;
case Y4M_CHROMA_422:
if(libdv_pal_yv12 == 1 )
mjpeg_error_exit1("must specify 4:2:0 chroma (should be '420paldv') with this input");
break;
default:
mjpeg_error_exit1("must specify 4:2:0 chroma (should be '420paldv') with this input");
break;
}
break;
case e_dv_sample_411:
if (param->chroma != Y4M_CHROMA_411)
mjpeg_info("chroma '411' recommended with this input");
switch (param->chroma) {
case Y4M_CHROMA_420MPEG2:
case Y4M_CHROMA_420PALDV:
mjpeg_warn("4:2:0 chroma should be '420jpeg' with this input");
break;
}
break;
case e_dv_sample_422:
if (param->chroma != Y4M_CHROMA_422)
mjpeg_info("chroma '422' recommended with this input");
switch (param->chroma) {
case Y4M_CHROMA_420MPEG2:
case Y4M_CHROMA_420PALDV:
mjpeg_warn("4:2:0 chroma should be '420jpeg' with this input");
break;
}
break;
default:
break;
}
#endif
break;
case DATAFORMAT_MJPG:
if (param->chroma != Y4M_CHROMA_422 && el.chroma == Y4M_CHROMA_422)
mjpeg_info("chroma '422' recommended with this input");
switch (param->chroma) {
case Y4M_CHROMA_420MPEG2:
case Y4M_CHROMA_420PALDV:
mjpeg_warn("4:2:0 chroma should be '420jpeg' with this input");
break;
}
break;
}
if (param->chroma == Y4M_UNKNOWN) {
mjpeg_info("set default chroma '420jpeg'");
param->chroma = Y4M_CHROMA_420JPEG;
}
y4m_si_set_chroma(streaminfo, param->chroma);
n = y4m_write_stream_header(out_fd, streaminfo);
if (n != Y4M_OK)
mjpeg_error("Failed to write stream header: %s", y4m_strerr(n));
}
/** parse_commandline
* Parses the commandline for the supplied parameters.
* in: argc, argv: the classic commandline parameters
*/
static void parse_commandline(int argc, char ** argv, parameters_t *param)
{
int c;
param->pngformatstr = NULL;
param->begin = 0;
param->numframes = -1;
param->framerate = y4m_fps_UNKNOWN;
param->interlace = Y4M_UNKNOWN;
param->interleave = -1;
param->verbose = 1;
param->ss_mode = DEFAULT_CHROMA_MODE;
//param->mza_filename = NULL;
//param->make_z_alpha = 0;
/* parse options */
for (;;) {
if (-1 == (c = getopt(argc, argv, "I:hv:L:b:j:n:f:z:S:")))
break;
switch (c) {
case 'j':
param->pngformatstr = strdup(optarg);
break;
#if 0
case 'z':
param->mza_filename = strdup(optarg);
param->make_z_alpha = 1;
break;
#else
case 'z':
mjpeg_error("Z encoding currently unsupported !\n");
exit(-1);
break;
#endif
case 'S':
param->ss_mode = y4m_chroma_parse_keyword(optarg);
if (param->ss_mode == Y4M_UNKNOWN) {
mjpeg_error_exit1("Unknown subsampling mode option: %s", optarg);
} else if (!chroma_sub_implemented(param->ss_mode)) {
mjpeg_error_exit1("Unsupported subsampling mode option: %s", optarg);
}
break;
case 'b':
param->begin = atol(optarg);
break;
case 'n':
param->numframes = atol(optarg);
break;
case 'f':
param->framerate = mpeg_conform_framerate(atof(optarg));
break;
case 'I':
switch (optarg[0]) {
case 'p':
param->interlace = Y4M_ILACE_NONE;
break;
case 't':
param->interlace = Y4M_ILACE_TOP_FIRST;
break;
case 'b':
param->interlace = Y4M_ILACE_BOTTOM_FIRST;
break;
default:
mjpeg_error_exit1 ("-I option requires arg p, t, or b");
}
break;
case 'L':
param->interleave = atoi(optarg);
if ((param->interleave != 0) &&
(param->interleave != 1))
mjpeg_error_exit1 ("-L option requires arg 0 or 1");
break;
case 'v':
param->verbose = atoi(optarg);
if (param->verbose < 0 || param->verbose > 2)
mjpeg_error_exit1( "-v option requires arg 0, 1, or 2");
break;
case 'h':
default:
usage(argv[0]);
exit(1);
}
}
if (param->pngformatstr == NULL)
{
mjpeg_error("%s: input format string not specified. (Use -j option.)",
argv[0]);
usage(argv[0]);
exit(1);
}
if (Y4M_RATIO_EQL(param->framerate, y4m_fps_UNKNOWN))
{
mjpeg_error("%s: framerate not specified. (Use -f option)",
argv[0]);
usage(argv[0]);
exit(1);
}
}
