static int put_image(struct vf_instance_s* vf, mp_image_t *mpi, double pts){
dv_encode_full_frame(vf->priv->enc, mpi->planes,
(mpi->flags&MP_IMGFLAG_YUV) ? e_dv_color_yuv : e_dv_color_rgb,
mux_v->buffer);
muxer_write_chunk(mux_v, 480 * (vf->priv->enc->isPAL ? 300 : 250) , 0x10, pts, pts);
return 1;
}
static void* t(void* arg)
{
int i = *((int*) arg);
struct frame_t* f;
unsigned char* rgb;
dv_encoder_t* enc;
fprintf(stderr, "thread %p: start frame %d\n", (void*) pthread_self(), i);
enc = dv_encoder_new(0, 0, 0);
enc->isPAL = 0;
enc->vlc_encode_passes = 3;
enc->static_qno = 0;
enc->force_dct = DV_DCT_AUTO;
f = &frame[i];
rgb = f->rgb;
dv_encode_full_frame(enc, &rgb, e_dv_color_rgb, f->dv);
dv_encoder_free(enc);
fprintf(stderr, "thread %p: done frame %d\n", (void*) pthread_self(), i);
return 0;
}
void dv_write_video(dv_t *dv,
unsigned char *data,
unsigned char **input_rows,
int color_model,
int norm)
{
dv_color_space_t encode_dv_colormodel = 0;
if(!dv->encoder)
{
dv->encoder = dv_encoder_new(
0,
0,
0);
}
switch( color_model )
{
case BC_YUV422:
encode_dv_colormodel = e_dv_color_yuv;
break;
case BC_RGB888:
encode_dv_colormodel = e_dv_color_rgb;
break;
default:
return;
break;
}
dv->encoder->is16x9 = 0;
dv->encoder->vlc_encode_passes = 3;
dv->encoder->static_qno = 0;
dv->encoder->force_dct = DV_DCT_AUTO;
dv->encoder->isPAL = (norm == DV_PAL);
dv_encode_full_frame( dv->encoder,
input_rows,
encode_dv_colormodel,
data );
}
int main( int argc, char **argv)
{
int infile = 0;
unsigned char dv_buffer[144000];
unsigned char video_buffer[720 * 576 * 3];
int16_t *audio_bufs[4];
dv_decoder_t *decoder = NULL;
dv_encoder_t *encoder = NULL;
int pitches[3];
unsigned char *pixels[3];
int i = 0, j;
int isPAL = FALSE;
pitches[0] = 720 * 2;
pixels[0] = video_buffer;
for(i = 0; i < 4; i++) {
audio_bufs[i] = malloc(DV_AUDIO_MAX_SAMPLES*sizeof(int16_t));
}
/* assume NTSC for now, switch to PAL later if needed */
decoder = dv_decoder_new(FALSE, FALSE, FALSE);
encoder = dv_encoder_new(FALSE, FALSE, FALSE);
decoder->quality = DV_QUALITY_BEST;
encoder->vlc_encode_passes = 3;
encoder->static_qno = 0;
encoder->force_dct = DV_DCT_AUTO;
i = 0;
while (read_frame(stdin, dv_buffer, &isPAL)) {
dv_parse_header(decoder, dv_buffer);
if (isPAL != encoder->isPAL && isPAL == TRUE) {
decoder->clamp_luma = FALSE;
decoder->clamp_chroma = FALSE;
encoder->clamp_luma = FALSE;
encoder->clamp_chroma = FALSE;
dv_reconfigure(FALSE, FALSE);
} else if (isPAL != encoder->isPAL) {
decoder->clamp_luma = TRUE;
decoder->clamp_chroma = TRUE;
decoder->add_ntsc_setup = TRUE;
encoder->clamp_luma = TRUE;
encoder->clamp_chroma = TRUE;
encoder->rem_ntsc_setup = TRUE;
dv_reconfigure(TRUE, TRUE);
}
encoder->isPAL = isPAL;
encoder->is16x9 = (dv_format_wide(decoder)>0);
dv_decode_full_audio(decoder, dv_buffer, audio_bufs);
for (j = 0; j < TIMES; j++) {
dv_decode_full_frame(decoder, dv_buffer, e_dv_color_yuv,
pixels, pitches);
dv_encode_full_frame(encoder, pixels, e_dv_color_yuv, dv_buffer);
}
dv_encode_full_audio(encoder, audio_bufs, 2, 48000, dv_buffer);
fwrite(dv_buffer, 1, (isPAL ? 144000 : 120000), stdout);
}
close(infile);
for(i=0; i < 4; i++) free(audio_bufs[i]);
dv_decoder_free(decoder);
dv_encoder_free(encoder);
return 0;
}
static int encode(quicktime_t *file, unsigned char **row_pointers, int track)
{
//int64_t offset = quicktime_position(file);
quicktime_video_map_t *vtrack = &(file->vtracks[track]);
quicktime_dv_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
quicktime_trak_t *trak = vtrack->track;
int width = trak->tkhd.track_width;
int height = trak->tkhd.track_height;
int width_i = 720;
int height_i = (height <= 480) ? 480 : 576;
int i;
unsigned char **input_rows;
int is_pal = (height_i == 480) ? 0 : 1;
int data_length = is_pal ? DV_PAL_SIZE : DV_NTSC_SIZE;
int result = 0;
dv_color_space_t encode_dv_colormodel = 0;
quicktime_atom_t chunk_atom;
if( codec->dv_encoder != NULL && codec->parameters_changed )
{
dv_encoder_free( codec->dv_encoder );
codec->dv_encoder = NULL;
codec->parameters_changed = 0;
}
if( ! codec->dv_encoder )
{
pthread_mutex_lock( &libdv_init_mutex );
//printf( "dv.c encode: Alloc'ing encoder\n" );
codec->dv_encoder = dv_encoder_new( codec->rem_ntsc_setup,
codec->clamp_luma,
codec->clamp_chroma );
codec->parameters_changed = 0;
pthread_mutex_unlock( &libdv_init_mutex );
}
if(codec->dv_encoder)
{
int is_sequential =
check_sequentiality( row_pointers,
width_i * cmodel_calculate_pixelsize(file->color_model),
height );
if( ( file->color_model == BC_YUV422
|| file->color_model == BC_RGB888 ) &&
width == width_i &&
height == height_i &&
is_sequential )
{
input_rows = row_pointers;
switch( file->color_model )
{
case BC_YUV422:
encode_dv_colormodel = e_dv_color_yuv;
//printf( "dv.c encode: e_dv_color_yuv\n" );
break;
case BC_RGB888:
encode_dv_colormodel = e_dv_color_rgb;
//printf( "dv.c encode: e_dv_color_rgb\n" );
break;
default:
return 0;
break;
}
}
else
{
// The best colormodel for encoding is YUV 422
if(!codec->temp_frame)
{
codec->temp_frame = malloc(720 * 576 * 2);
codec->temp_rows = malloc(sizeof(unsigned char*) * 576);
for(i = 0; i < 576; i++)
codec->temp_rows[i] = codec->temp_frame + 720 * 2 * i;
}
cmodel_transfer(codec->temp_rows, /* Leave NULL if non existent */
row_pointers,
codec->temp_rows[0], /* Leave NULL if non existent */
codec->temp_rows[1],
codec->temp_rows[2],
row_pointers[0], /* Leave NULL if non existent */
row_pointers[1],
row_pointers[2],
0, /* Dimensions to capture from input frame */
0,
MIN(width, width_i),
MIN(height, height_i),
0, /* Dimensions to project on output frame */
0,
MIN(width, width_i),
MIN(height, height_i),
file->color_model,
BC_YUV422,
0, /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
width, /* For planar use the luma rowspan */
width_i);
input_rows = codec->temp_rows;
encode_dv_colormodel = e_dv_color_yuv;
}
// Setup the encoder
codec->dv_encoder->is16x9 = codec->anamorphic16x9;
codec->dv_encoder->vlc_encode_passes = codec->vlc_encode_passes;
codec->dv_encoder->static_qno = 0;
codec->dv_encoder->force_dct = DV_DCT_AUTO;
codec->dv_encoder->isPAL = is_pal;
//printf("dv.c encode: 1 %d %d %d\n", width_i, height_i, encode_dv_colormodel);
dv_encode_full_frame( codec->dv_encoder,
input_rows, encode_dv_colormodel, codec->data );
//printf("dv.c encode: 2 %d %d\n", width_i, height_i);
quicktime_write_chunk_header(file, trak, &chunk_atom);
result = !quicktime_write_data(file, (char*)codec->data, data_length);
quicktime_write_chunk_footer(file,
trak,
vtrack->current_chunk,
&chunk_atom,
1);
vtrack->current_chunk++;
//printf("encode 3\n");
}
return result;
}
