X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=x264.c;h=fe5057f248283881ad3243b085de9523a433f30a;hb=4c8ccfe6de4a44cd46bcaf1fc17ae90bfe34d958;hp=2d261868e26b1e401faf020f2340f1f8baeaa309;hpb=396133936510d57bc2054dd1c1d3d92fa0eb5495;p=x264 diff --git a/x264.c b/x264.c index 2d261868..fe5057f2 100644 --- a/x264.c +++ b/x264.c @@ -42,15 +42,19 @@ #endif #ifdef MP4_OUTPUT -#include +#include #endif + #include "common/common.h" #include "x264.h" + #ifndef _MSC_VER #include "config.h" #endif +#include "matroska.h" + #define DATA_MAX 3000000 uint8_t data[DATA_MAX]; @@ -114,6 +118,12 @@ static int set_eop_mp4( hnd_t handle, x264_picture_t *p_picture ); static int close_file_mp4( hnd_t handle ); #endif +static int open_file_mkv( char *psz_filename, hnd_t *p_handle ); +static int set_param_mkv( hnd_t handle, x264_param_t *p_param ); +static int write_nalu_mkv( hnd_t handle, uint8_t *p_nal, int i_size ); +static int set_eop_mkv( hnd_t handle, x264_picture_t *p_picture ); +static int close_file_mkv( hnd_t handle ); + static void Help( x264_param_t *defaults ); static int Parse( int argc, char **argv, x264_param_t *param, cli_opt_t *opt ); static int Encode( x264_param_t *param, cli_opt_t *opt ); @@ -157,6 +167,7 @@ static void Help( x264_param_t *defaults ) " or AVI or Avisynth if compiled with AVIS support (%s).\n" "Outfile type is selected by filename:\n" " .264 -> Raw bytestream\n" + " .mkv -> Matroska\n" " .mp4 -> MP4 if compiled with GPAC support (%s)\n" "\n" "Options:\n" @@ -232,6 +243,19 @@ static void Help( x264_param_t *defaults ) " --no-chroma-me Ignore chroma in motion estimation\n" " -8, --8x8dct Adaptive spatial transform size\n" "\n" + " --cqm Preset quant matrices [\"flat\"]\n" + " - jvt, flat\n" + " --cqmfile Read quant matrices from a JM-compatible file\n" + " Overrides any other --cqm* options.\n" + " --cqm4 Set all 4x4 quant matrices\n" + " Takes a comma-separated list of 16 integers.\n" + " --cqm8 Set all 8x8 quant matrices\n" + " Takes a comma-separated list of 64 integers.\n" + " --cqm4i, --cqm4p, --cqm8i, --cqm8p\n" + " Set both luma and chroma quant matrices\n" + " --cqm4iy, --cqm4ic, --cqm4py, --cqm4pc\n" + " Set individual quant matrices\n" + "\n" "Input/Output:\n" "\n" " --level Specify level (as defined by Annex A)\n" @@ -294,6 +318,18 @@ static void Help( x264_param_t *defaults ) ); } +static int parse_cqm( const char *str, uint8_t *cqm, int length ) +{ + int i = 0; + do { + int coef; + if( !sscanf( str, "%d", &coef ) || coef < 1 || coef > 255 ) + return -1; + cqm[i++] = coef; + } while( i < length && (str = strchr( str, ',' )) && str++ ); + return (i == length) ? 0 : -1; +} + /***************************************************************************** * Parse: *****************************************************************************/ @@ -324,6 +360,7 @@ static int Parse( int argc, char **argv, opterr = 0; // no error message for( ;; ) { + int b_error = 0; int long_options_index; #define OPT_QPMIN 256 #define OPT_QPMAX 257 @@ -360,6 +397,18 @@ static int Parse( int argc, char **argv, #define OPT_SEEK 291 #define OPT_ZONES 292 #define OPT_THREADS 293 +#define OPT_CQM 294 +#define OPT_CQM4 295 +#define OPT_CQM4I 296 +#define OPT_CQM4IY 297 +#define OPT_CQM4IC 298 +#define OPT_CQM4P 299 +#define OPT_CQM4PY 300 +#define OPT_CQM4PC 301 +#define OPT_CQM8 302 +#define OPT_CQM8I 303 +#define OPT_CQM8P 304 +#define OPT_CQMFILE 305 static struct option long_options[] = { @@ -416,6 +465,18 @@ static int Parse( int argc, char **argv, { "progress",no_argument, NULL, OPT_PROGRESS }, { "visualize",no_argument, NULL, OPT_VISUALIZE }, { "aud", no_argument, NULL, OPT_AUD }, + { "cqm", required_argument, NULL, OPT_CQM }, + { "cqmfile", required_argument, NULL, OPT_CQMFILE }, + { "cqm4", required_argument, NULL, OPT_CQM4 }, + { "cqm4i", required_argument, NULL, OPT_CQM4I }, + { "cqm4iy", required_argument, NULL, OPT_CQM4IY }, + { "cqm4ic", required_argument, NULL, OPT_CQM4IC }, + { "cqm4p", required_argument, NULL, OPT_CQM4P }, + { "cqm4py", required_argument, NULL, OPT_CQM4PY }, + { "cqm4pc", required_argument, NULL, OPT_CQM4PC }, + { "cqm8", required_argument, NULL, OPT_CQM8 }, + { "cqm8i", required_argument, NULL, OPT_CQM8I }, + { "cqm8p", required_argument, NULL, OPT_CQM8P }, {0, 0, 0, 0} }; @@ -455,9 +516,13 @@ static int Parse( int argc, char **argv, break; case 'i': param->i_keyint_min = atol( optarg ); + if( param->i_keyint_max < param->i_keyint_min ) + param->i_keyint_max = param->i_keyint_min; break; case 'I': param->i_keyint_max = atol( optarg ); + if( param->i_keyint_min > param->i_keyint_max ) + param->i_keyint_min = param->i_keyint_max; break; case OPT_SCENECUT: param->i_scenecut_threshold = atol( optarg ); @@ -502,7 +567,7 @@ static int Parse( int argc, char **argv, case OPT_SEEK: opt->i_seek = atoi( optarg ); break; - case'o': + case 'o': if( !strncasecmp(optarg + strlen(optarg) - 4, ".mp4", 4) ) { #ifdef MP4_OUTPUT @@ -516,6 +581,14 @@ static int Parse( int argc, char **argv, return -1; #endif } + else if( !strncasecmp(optarg + strlen(optarg) - 4, ".mkv", 4) ) + { + p_open_outfile = open_file_mkv; + p_write_nalu = write_nalu_mkv; + p_set_outfile_param = set_param_mkv; + p_set_eop = set_eop_mkv; + p_close_outfile = close_file_mkv; + } if( !strcmp(optarg, "-") ) opt->hout = stdout; else if( p_open_outfile( optarg, &opt->hout ) ) @@ -603,7 +676,7 @@ static int Parse( int argc, char **argv, param->i_level_idc = atoi(optarg); break; case OPT_RATETOL: - param->rc.f_rate_tolerance = atof(optarg); + param->rc.f_rate_tolerance = !strncmp("inf", optarg, 3) ? 1e9 : atof(optarg); break; case OPT_VBVMAXRATE: param->rc.i_vbv_max_bitrate = atoi( optarg ); @@ -680,10 +753,76 @@ static int Parse( int argc, char **argv, fprintf( stderr, "not compiled with visualization support\n" ); #endif break; + case OPT_CQM: + if( strstr( optarg, "flat" ) ) + param->i_cqm_preset = X264_CQM_FLAT; + else if( strstr( optarg, "jvt" ) ) + param->i_cqm_preset = X264_CQM_JVT; + else + { + fprintf( stderr, "bad CQM preset `%s'\n", optarg ); + return -1; + } + break; + case OPT_CQMFILE: + param->psz_cqm_file = optarg; + break; + case OPT_CQM4: + param->i_cqm_preset = X264_CQM_CUSTOM; + b_error |= parse_cqm( optarg, param->cqm_4iy, 16 ); + b_error |= parse_cqm( optarg, param->cqm_4ic, 16 ); + b_error |= parse_cqm( optarg, param->cqm_4py, 16 ); + b_error |= parse_cqm( optarg, param->cqm_4pc, 16 ); + break; + case OPT_CQM8: + param->i_cqm_preset = X264_CQM_CUSTOM; + b_error |= parse_cqm( optarg, param->cqm_8iy, 64 ); + b_error |= parse_cqm( optarg, param->cqm_8py, 64 ); + break; + case OPT_CQM4I: + param->i_cqm_preset = X264_CQM_CUSTOM; + b_error |= parse_cqm( optarg, param->cqm_4iy, 16 ); + b_error |= parse_cqm( optarg, param->cqm_4ic, 16 ); + break; + case OPT_CQM4P: + param->i_cqm_preset = X264_CQM_CUSTOM; + b_error |= parse_cqm( optarg, param->cqm_4py, 16 ); + b_error |= parse_cqm( optarg, param->cqm_4pc, 16 ); + break; + case OPT_CQM4IY: + param->i_cqm_preset = X264_CQM_CUSTOM; + b_error |= parse_cqm( optarg, param->cqm_4iy, 16 ); + break; + case OPT_CQM4IC: + param->i_cqm_preset = X264_CQM_CUSTOM; + b_error |= parse_cqm( optarg, param->cqm_4ic, 16 ); + break; + case OPT_CQM4PY: + param->i_cqm_preset = X264_CQM_CUSTOM; + b_error |= parse_cqm( optarg, param->cqm_4iy, 16 ); + break; + case OPT_CQM4PC: + param->i_cqm_preset = X264_CQM_CUSTOM; + b_error |= parse_cqm( optarg, param->cqm_4ic, 16 ); + break; + case OPT_CQM8I: + param->i_cqm_preset = X264_CQM_CUSTOM; + b_error |= parse_cqm( optarg, param->cqm_8iy, 64 ); + break; + case OPT_CQM8P: + param->i_cqm_preset = X264_CQM_CUSTOM; + b_error |= parse_cqm( optarg, param->cqm_8py, 64 ); + break; default: fprintf( stderr, "unknown option (%c)\n", optopt ); return -1; } + + if( b_error ) + { + fprintf( stderr, "bad argument (%s)\n", optarg ); + return -1; + } } /* Get the file name */ @@ -704,8 +843,8 @@ static int Parse( int argc, char **argv, if( *psz >= '0' && *psz <= '9' && sscanf( psz, "%ux%u", ¶m->i_width, ¶m->i_height ) == 2 ) { - if( param->i_log_level > X264_LOG_NONE ) - fprintf( stderr, "x264: file name gives %dx%d\n", param->i_width, param->i_height ); + if( param->i_log_level >= X264_LOG_INFO ) + fprintf( stderr, "x264 [info]: file name gives %dx%d\n", param->i_width, param->i_height ); break; } } @@ -989,7 +1128,7 @@ static int Encode( x264_param_t *param, cli_opt_t *opt ) if( p_read_frame( &pic, opt->hin, i_frame + opt->i_seek, param->i_width, param->i_height ) ) break; - pic.i_pts = i_frame * param->i_fps_den; + pic.i_pts = (int64_t)i_frame * param->i_fps_den; i_file += Encode_frame( h, opt->hout, &pic ); @@ -997,13 +1136,19 @@ static int Encode( x264_param_t *param, cli_opt_t *opt ) /* update status line (up to 1000 times per input file) */ if( opt->b_progress && param->i_log_level < X264_LOG_DEBUG && - i_frame * 1000 / i_frame_total > i_progress ) + ( i_frame_total ? i_frame * 1000 / i_frame_total > i_progress + : i_frame % 10 == 0 ) ) { int64_t i_elapsed = x264_mdate() - i_start; double fps = i_elapsed > 0 ? i_frame * 1000000. / i_elapsed : 0; - i_progress = i_frame * 1000 / i_frame_total; - fprintf( stderr, "encoded frames: %d/%d (%.1f%%), %.2f fps \r", i_frame, - i_frame_total, (float)i_progress / 10, fps ); + if( i_frame_total ) + { + i_progress = i_frame * 1000 / i_frame_total; + fprintf( stderr, "encoded frames: %d/%d (%.1f%%), %.2f fps \r", i_frame, + i_frame_total, (float)i_progress / 10, fps ); + } + else + fprintf( stderr, "encoded frames: %d, %.2f fps \r", i_frame, fps ); fflush( stderr ); // needed in windows } } @@ -1229,9 +1374,9 @@ static int close_file_bsf( hnd_t handle ) typedef struct { - M4File *p_file; - AVCConfig *p_config; - M4Sample *p_sample; + GF_ISOFile *p_file; + GF_AVCConfig *p_config; + GF_ISOSample *p_sample; int i_track; int i_descidx; int i_time_inc; @@ -1243,24 +1388,24 @@ typedef struct } mp4_t; -static void recompute_bitrate_mp4(M4File *p_file, int i_track) +static void recompute_bitrate_mp4(GF_ISOFile *p_file, int i_track) { u32 i, count, di, timescale, time_wnd, rate; u64 offset; Double br; - ESDescriptor *esd; + GF_ESD *esd; - esd = M4_GetStreamDescriptor(p_file, i_track, 1); + esd = gf_isom_get_esd(p_file, i_track, 1); if (!esd) return; esd->decoderConfig->avgBitrate = 0; esd->decoderConfig->maxBitrate = 0; rate = time_wnd = 0; - timescale = M4_GetMediaTimeScale(p_file, i_track); - count = M4_GetSampleCount(p_file, i_track); + timescale = gf_isom_get_media_timescale(p_file, i_track); + count = gf_isom_get_sample_count(p_file, i_track); for (i=0; idataLength>esd->decoderConfig->bufferSizeDB) esd->decoderConfig->bufferSizeDB = samp->dataLength; @@ -1273,18 +1418,18 @@ static void recompute_bitrate_mp4(M4File *p_file, int i_track) rate = 0; } - M4_DeleteSample(&samp); + gf_isom_sample_del(&samp); } - br = (Double) (s64) M4_GetMediaDuration(p_file, i_track); + br = (Double) (s64) gf_isom_get_media_duration(p_file, i_track); br /= timescale; esd->decoderConfig->avgBitrate = (u32) (esd->decoderConfig->avgBitrate / br); /*move to bps*/ esd->decoderConfig->avgBitrate *= 8; esd->decoderConfig->maxBitrate *= 8; - M4_ChangeStreamDescriptor(p_file, i_track, 1, esd); - OD_DeleteDescriptor((Descriptor **)&esd); + gf_isom_change_mpeg4_description(p_file, i_track, 1, esd); + gf_odf_desc_del((GF_Descriptor *) esd); } @@ -1296,22 +1441,22 @@ static int close_file_mp4( hnd_t handle ) return 0; if (p_mp4->p_config) - AVC_DeleteConfig(p_mp4->p_config); + gf_odf_avc_cfg_del(p_mp4->p_config); if (p_mp4->p_sample) { if (p_mp4->p_sample->data) free(p_mp4->p_sample->data); - M4_DeleteSample(&p_mp4->p_sample); + gf_isom_sample_del(&p_mp4->p_sample); } if (p_mp4->p_file) { recompute_bitrate_mp4(p_mp4->p_file, p_mp4->i_track); - M4_SetMoviePLIndication(p_mp4->p_file, M4_PL_VISUAL, 0x15); - M4_SetStorageMode(p_mp4->p_file, M4_FLAT); - M4_MovieClose(p_mp4->p_file); + gf_isom_set_pl_indication(p_mp4->p_file, GF_ISOM_PL_VISUAL, 0x15); + gf_isom_set_storage_mode(p_mp4->p_file, GF_ISOM_STORE_FLAT); + gf_isom_close(p_mp4->p_file); } free(p_mp4); @@ -1329,15 +1474,15 @@ static int open_file_mp4( char *psz_filename, hnd_t *p_handle ) return -1; memset(p_mp4, 0, sizeof(mp4_t)); - p_mp4->p_file = M4_MovieOpen(psz_filename, M4_OPEN_WRITE); + p_mp4->p_file = gf_isom_open(psz_filename, GF_ISOM_OPEN_WRITE, NULL); - if ((p_mp4->p_sample = M4_NewSample()) == NULL) + if ((p_mp4->p_sample = gf_isom_sample_new()) == NULL) { close_file_mp4( p_mp4 ); return -1; } - M4_SetMovieVersionInfo(p_mp4->p_file, H264_AVC_File, 0); + gf_isom_set_brand_info(p_mp4->p_file, GF_ISOM_BRAND_AVC1, 0); *p_handle = p_mp4; @@ -1349,14 +1494,14 @@ static int set_param_mp4( hnd_t handle, x264_param_t *p_param ) { mp4_t *p_mp4 = (mp4_t *)handle; - p_mp4->i_track = M4_NewTrack(p_mp4->p_file, 0, M4_VisualMediaType, + p_mp4->i_track = gf_isom_new_track(p_mp4->p_file, 0, GF_ISOM_MEDIA_VISUAL, p_param->i_fps_num); - p_mp4->p_config = AVC_NewConfig(); - M4_AVC_NewStreamConfig(p_mp4->p_file, p_mp4->i_track, p_mp4->p_config, + p_mp4->p_config = gf_odf_avc_cfg_new(); + gf_isom_avc_config_new(p_mp4->p_file, p_mp4->i_track, p_mp4->p_config, NULL, NULL, &p_mp4->i_descidx); - M4_SetVisualEntrySize(p_mp4->p_file, p_mp4->i_track, p_mp4->i_descidx, + gf_isom_set_visual_info(p_mp4->p_file, p_mp4->i_track, p_mp4->i_descidx, p_param->i_width, p_param->i_height); p_mp4->p_sample->data = (char *)malloc(p_param->i_width * p_param->i_height * 3 / 2); @@ -1377,7 +1522,7 @@ static int set_param_mp4( hnd_t handle, x264_param_t *p_param ) static int write_nalu_mp4( hnd_t handle, uint8_t *p_nalu, int i_size ) { mp4_t *p_mp4 = (mp4_t *)handle; - AVCConfigSlot *p_slot; + GF_AVCConfigSlot *p_slot; uint8_t type = p_nalu[4] & 0x1f; int psize; @@ -1391,11 +1536,11 @@ static int write_nalu_mp4( hnd_t handle, uint8_t *p_nalu, int i_size ) p_mp4->p_config->AVCProfileIndication = p_nalu[5]; p_mp4->p_config->profile_compatibility = p_nalu[6]; p_mp4->p_config->AVCLevelIndication = p_nalu[7]; - p_slot = (AVCConfigSlot *)malloc(sizeof(AVCConfigSlot)); + p_slot = (GF_AVCConfigSlot *)malloc(sizeof(GF_AVCConfigSlot)); p_slot->size = i_size - 4; p_slot->data = (char *)malloc(p_slot->size); memcpy(p_slot->data, p_nalu + 4, i_size - 4); - ChainAddEntry(p_mp4->p_config->sequenceParameterSets, p_slot); + gf_list_add(p_mp4->p_config->sequenceParameterSets, p_slot); p_slot = NULL; p_mp4->b_sps = 1; } @@ -1405,15 +1550,15 @@ static int write_nalu_mp4( hnd_t handle, uint8_t *p_nalu, int i_size ) case 0x08: if (!p_mp4->b_pps) { - p_slot = (AVCConfigSlot *)malloc(sizeof(AVCConfigSlot)); + p_slot = (GF_AVCConfigSlot *)malloc(sizeof(GF_AVCConfigSlot)); p_slot->size = i_size - 4; p_slot->data = (char *)malloc(p_slot->size); memcpy(p_slot->data, p_nalu + 4, i_size - 4); - ChainAddEntry(p_mp4->p_config->pictureParameterSets, p_slot); + gf_list_add(p_mp4->p_config->pictureParameterSets, p_slot); p_slot = NULL; p_mp4->b_pps = 1; if (p_mp4->b_sps) - M4_AVC_UpdateStreamConfig(p_mp4->p_file, p_mp4->i_track, 1, p_mp4->p_config); + gf_isom_avc_config_update(p_mp4->p_file, p_mp4->i_track, 1, p_mp4->p_config); } break; @@ -1444,7 +1589,7 @@ static int set_eop_mp4( hnd_t handle, x264_picture_t *p_picture ) p_mp4->p_sample->IsRAP = p_picture->i_type == X264_TYPE_IDR ? 1 : 0; p_mp4->p_sample->DTS = dts; p_mp4->p_sample->CTS_Offset = offset; - M4_AddSample(p_mp4->p_file, p_mp4->i_track, p_mp4->i_descidx, p_mp4->p_sample); + gf_isom_add_sample(p_mp4->p_file, p_mp4->i_track, p_mp4->i_descidx, p_mp4->p_sample); p_mp4->p_sample->dataLength = 0; p_mp4->i_numframe++; @@ -1453,3 +1598,237 @@ static int set_eop_mp4( hnd_t handle, x264_picture_t *p_picture ) } #endif + + +/* -- mkv muxing support ------------------------------------------------- */ +typedef struct +{ + mk_Writer *w; + + uint8_t *sps, *pps; + int sps_len, pps_len; + + int width, height, d_width, d_height; + + int64_t frame_duration; + int fps_num; + + int b_header_written; + char b_writing_frame; +} mkv_t; + +static int write_header_mkv( mkv_t *p_mkv ) +{ + int ret; + uint8_t *avcC; + int avcC_len; + + if( p_mkv->sps == NULL || p_mkv->pps == NULL || + p_mkv->width == 0 || p_mkv->height == 0 || + p_mkv->d_width == 0 || p_mkv->d_height == 0) + return -1; + + avcC_len = 5 + 1 + 2 + p_mkv->sps_len + 1 + 2 + p_mkv->pps_len; + avcC = malloc(avcC_len); + if (avcC == NULL) + return -1; + + avcC[0] = 1; + avcC[1] = p_mkv->sps[1]; + avcC[2] = p_mkv->sps[2]; + avcC[3] = p_mkv->sps[3]; + avcC[4] = 0xfe; // nalu size length is three bytes + avcC[5] = 0xe1; // one sps + + avcC[6] = p_mkv->sps_len >> 8; + avcC[7] = p_mkv->sps_len; + + memcpy(avcC+8, p_mkv->sps, p_mkv->sps_len); + + avcC[8+p_mkv->sps_len] = 1; // one pps + avcC[9+p_mkv->sps_len] = p_mkv->pps_len >> 8; + avcC[10+p_mkv->sps_len] = p_mkv->pps_len; + + memcpy( avcC+11+p_mkv->sps_len, p_mkv->pps, p_mkv->pps_len ); + + ret = mk_writeHeader( p_mkv->w, "x264", "V_MPEG4/ISO/AVC", + avcC, avcC_len, p_mkv->frame_duration, 50000, + p_mkv->width, p_mkv->height, + p_mkv->d_width, p_mkv->d_height ); + + free( avcC ); + + p_mkv->b_header_written = 1; + + return ret; +} + +static int open_file_mkv( char *psz_filename, hnd_t *p_handle ) +{ + mkv_t *p_mkv; + + *p_handle = NULL; + + p_mkv = malloc(sizeof(*p_mkv)); + if (p_mkv == NULL) + return -1; + + memset(p_mkv, 0, sizeof(*p_mkv)); + + p_mkv->w = mk_createWriter(psz_filename); + if (p_mkv->w == NULL) + { + free(p_mkv); + return -1; + } + + *p_handle = p_mkv; + + return 0; +} + +static int set_param_mkv( hnd_t handle, x264_param_t *p_param ) +{ + mkv_t *p_mkv = handle; + int64_t dw, dh; + + if( p_param->i_fps_num > 0 ) + { + p_mkv->frame_duration = (int64_t)p_param->i_fps_den * + (int64_t)1000000000 / p_param->i_fps_num; + p_mkv->fps_num = p_param->i_fps_num; + } + else + { + p_mkv->frame_duration = 0; + p_mkv->fps_num = 1; + } + + p_mkv->width = p_param->i_width; + p_mkv->height = p_param->i_height; + + if( p_param->vui.i_sar_width && p_param->vui.i_sar_height ) + { + dw = (int64_t)p_param->i_width * p_param->vui.i_sar_width; + dh = (int64_t)p_param->i_height * p_param->vui.i_sar_height; + } + else + { + dw = p_param->i_width; + dh = p_param->i_height; + } + + if( dw > 0 && dh > 0 ) + { + int64_t a = dw, b = dh; + + for (;;) + { + int64_t c = a % b; + if( c == 0 ) + break; + a = b; + b = c; + } + + dw /= b; + dh /= b; + } + + p_mkv->d_width = (int)dw; + p_mkv->d_height = (int)dh; + + return 0; +} + +static int write_nalu_mkv( hnd_t handle, uint8_t *p_nalu, int i_size ) +{ + mkv_t *p_mkv = handle; + uint8_t type = p_nalu[4] & 0x1f; + uint8_t dsize[3]; + int psize; + + switch( type ) + { + // sps + case 0x07: + if( !p_mkv->sps ) + { + p_mkv->sps = malloc(i_size - 4); + if (p_mkv->sps == NULL) + return -1; + p_mkv->sps_len = i_size - 4; + memcpy(p_mkv->sps, p_nalu + 4, i_size - 4); + } + break; + + // pps + case 0x08: + if( !p_mkv->pps ) + { + p_mkv->pps = malloc(i_size - 4); + if (p_mkv->pps == NULL) + return -1; + p_mkv->pps_len = i_size - 4; + memcpy(p_mkv->pps, p_nalu + 4, i_size - 4); + } + break; + + // slice, sei + case 0x1: + case 0x5: + case 0x6: + if( !p_mkv->b_writing_frame ) + { + if( mk_startFrame(p_mkv->w) < 0 ) + return -1; + p_mkv->b_writing_frame = 1; + } + psize = i_size - 4 ; + dsize[0] = psize >> 16; + dsize[1] = psize >> 8; + dsize[2] = psize; + if( mk_addFrameData(p_mkv->w, dsize, 3) < 0 || + mk_addFrameData(p_mkv->w, p_nalu + 4, i_size - 4) < 0 ) + return -1; + break; + + default: + break; + } + + if( !p_mkv->b_header_written && p_mkv->pps && p_mkv->sps && + write_header_mkv(p_mkv) < 0 ) + return -1; + + return i_size; +} + +static int set_eop_mkv( hnd_t handle, x264_picture_t *p_picture ) +{ + mkv_t *p_mkv = handle; + int64_t i_stamp = (int64_t)(p_picture->i_pts * 1e9 / p_mkv->fps_num); + + p_mkv->b_writing_frame = 0; + + return mk_setFrameFlags( p_mkv->w, i_stamp, + p_picture->i_type == X264_TYPE_IDR ); +} + +static int close_file_mkv( hnd_t handle ) +{ + mkv_t *p_mkv = handle; + int ret; + + if( p_mkv->sps ) + free( p_mkv->sps ); + if( p_mkv->pps ) + free( p_mkv->pps ); + + ret = mk_close(p_mkv->w); + + free( p_mkv ); + + return ret; +} +