parse_video_cmdline.c

Sample code for use on smp 863x processor.

#define ALLOW_OS_CODE 1
#include "../rua/include/rua.h"
#include "../dcc/include/dcc.h"
#include "common.h"
#include "sample_os.h"
#include "../samples/rmttx.h"

#undef DEBUG
#define DEBUG	DISABLE

extern RMbool manutest;

struct profile_record {
	char*							profile_id;
	enum MPEG_Profile				profile_profile;
	enum VideoDecoder_Codec_type	profile_codec;
};

#define	PROFILE_ENTRY(name, value)	{ name, Profile_##value , VideoDecoder_Codec_##value, },
#define	PROFILE_END()				{ 0, 0, 0, },

/* lookup table for video profiles */
struct profile_record	profile_table[] = {
	PROFILE_ENTRY("2sd", 	MPEG2_SD)
	PROFILE_ENTRY("3sd",	DIVX3_SD)	
	PROFILE_ENTRY("4sd", 	MPEG4_SD)
	PROFILE_ENTRY("4sdr",	MPEG4_SD_Padding)
	PROFILE_ENTRY("2dvd", 	MPEG2_DVD)
	PROFILE_ENTRY("2hd",	MPEG2_HD)
	PROFILE_ENTRY("3hd",	DIVX3_HD)
	PROFILE_ENTRY("4hd",	MPEG4_HD)
	PROFILE_ENTRY("4hdr",	MPEG4_HD_Padding)
	PROFILE_ENTRY("2sddi", 	MPEG2_SD_DeInt)
	PROFILE_ENTRY("4sddi",	MPEG4_SD_DeInt)
	PROFILE_ENTRY("4sddir",	MPEG4_SD_DeInt_Padding)
	PROFILE_ENTRY("2dvddi",	MPEG2_DVD_DeInt)
	PROFILE_ENTRY("2hddi",	MPEG2_HD_DeInt)
	PROFILE_ENTRY("4hddi",	MPEG4_HD_DeInt)
	PROFILE_ENTRY("4hddir",	MPEG4_HD_DeInt_Padding)
	PROFILE_ENTRY("9sd",	WMV_SD)
	PROFILE_ENTRY("9816p",	WMV_816P)
	PROFILE_ENTRY("9hd",	WMV_HD)
	PROFILE_ENTRY("5sd",	H264_SD)
	PROFILE_ENTRY("5hd",	H264_HD)
	PROFILE_ENTRY("5sddi",	H264_SD_DeInt)
	PROFILE_ENTRY("5hddi",	H264_HD_DeInt)
	PROFILE_ENTRY("10sd",	VC1_SD)
	PROFILE_ENTRY("10hd",	VC1_HD)
	
	PROFILE_END()
};

/* look up profile name, store profile identifier */
RMstatus get_profile_profile(const char* prof, enum MPEG_Profile* profile) {
	int i;
	
	for (i = 0 ; profile_table[i].profile_id != 0L ; i++) {
		if (strcmp(profile_table[i].profile_id, prof) == 0) {
			*profile = profile_table[i].profile_profile;
			return RM_OK;
		}
	}
	
	return RM_ERROR;
}

/* look up profile name, store video decoder identifier */
RMstatus get_profile_codec(const char* prof, enum VideoDecoder_Codec_type* type) {
	int i;
	
	for (i = 0 ; profile_table[i].profile_id != 0L ; i++) {
		if (strcmp(profile_table[i].profile_id, prof) == 0) {
			*type = profile_table[i].profile_codec;
			return RM_OK;
		}
	}
	
	return RM_ERROR;
}

static 	RMuint8 ccbuf[256], dtvbuf[128];
static RMuint32 ccsize = 0, dtvsize = 0;

void show_video_options(void)
{
	fprintf(stderr, "VIDEO OPTIONS (default values inside brackets)\n"
		"\t-2: Selects MPEG2-HD [default]\n"
		"\t-3: Selects DivX3.11-SD\n"
		"\t-4: Selects MPEG4-SD\n"
		"\t-5: Selects H264-SD\n"
		"\t-9: Selects WMV_816P\n"
		"\t-10: Selects VC-1 AP HD\n"
		"\t-p profile: 2=MPEG-1/2, 3=DivX3.11, 4=MPEG-4, 5=H.264, 9=WMV or \n"
		"\t            VC-1 MP, 10=VC-1 AP"
		"\t-v codec:\n"
		"\t-pv codec: 2sd 4sd 4sdr 2dvd [2hd] 4hd 4hdr 2sddi 4sddi 4sddir \n"
		"\t           2dvddi 2hddi 4hddi 4hddir 9sd 9816p 9hd 3sd 3hd 5sd \n"
		"\t           5hd 10sd 10hd auto\n"
		"\t-ve video engine: selects the video engine (DSP) to be used, 0 or 1 [0]\n"
		"\t-vd video decoder: selects the video decoder on the DSP to use. [0]\n"
		"\t-fixvop <resolution per second> <increment per frame>: \n"
		"\t-vtimescale <pts time resolution>: \n"
		"\t          play m4v with pts expressed in vtimescale units. For mpeg4 over m2t use 45000.\n"
		"\t-ics colorspace: Forces the input colorspace. [yuv_601] yuv_709 \n"
		"\t                 rgb_0_255 rgb_16_235\n"
		"\t-cc closed_caption_mode: Selects the closed caption display mode.\n"
		"\t                         [tv] soft (608soft cc1) cc2 cc3 cc4 708soft off\n"
		"\t-vcodec codec width height: Selects the video codec.\n"
		"\t          codec: mpeg2, mpeg4, divx3, vc1, wmv, h264, jpeg.\n"
		"\t-extrapict: number of extra picture buffers for display[0]\n"
		"\t-vprofile: baseline h264 0, main is 1.[0]\n"
		"\t-vlevel:   level: 0..14 is L1..L5.1 for h264.[0]\n"
		"\t                         [tv] 608soft 708soft off\n"
		"\t-vfifo size: select the video bitstream fifo size in KB. Default is application dependent\n"
		"\t-vxfer count: select the video xfer fifo count. Default is application dependent\n"
		"\t-ms : enable playback of MS elemtary with PTS files\n"
		"\t-seq : WMV9 sequence parameter (Decimal or 0xXXXXXXXX Hexadecimal)\n"
		"\t-scan <mode>: sets video scan mode: [source] frame top bot\n"
		"\t-displayerror <threshold>: sets display error threshold [0]\n"
		"\t-err_prop_threshold <threshold> : sets anchor error propagation threshold\n"
		"\t-err_prop_length <length> : sets anchor error propagation length\n"
		"\t-lowdelay: used to set lowdelay mode and display pictures as soon as their are decoded [FALSE]\n"
		"\t-intprog algorithm: Selects the interlaced_progressive algorithm: [std], mpeg2_prog_seq, mpeg2_menu_prog\n"
		"\t-use_afd: parse Active Format information from MPEG2 or H.264 streams and adjust the display accordingly\n"
		"\t-act <active format>: force active format for the content\n"
		"\t\t[none], full, 16x9top, 14x9top, 64x27, 4x3, 16x9, 14x9, 4x3_14x9, 16x9_14x9, 16x9_4x3\n"
		"\t-skipNCP <value>: skip (1) or not to skip (0) NotCoded P-frames: [0] 1\n"
		);
}

RMstatus init_video_options(struct video_cmdline *options)
{
	RMDBGLOG((ENABLE, "\n*********************init_video_options\n\n"));

	options->MpegEngineID = 0;
	options->VideoDecoderID = 0;
 	options->MPEGProfile = Profile_MPEG2_HD;
	options->Codec = VideoDecoder_Codec_MPEG2_HD;
	options->VopInfo.FixedVopRate = FALSE;			// by default don't use fixed rate
	options->VopInfo.VopTimeIncrementResolution = 30000;	// ticks per second
	options->VopInfo.FixedVopTimeIncrement = 1000;		// ticks per frame
	options->vtimescale.enable = FALSE;
	options->vtimescale.time_resolution = 45000;
	options->input_color_space = EMhwlibColorSpace_YUV_601;
	options->force_input_color_space = FALSE;
	options->display_ttx = FALSE;
	
	/* default CC is TV */
	options->display_cc = TRUE;
	options->cc_select = EMhwlibCCSelect_CC1;
	options->use_soft_cc_decoder = 0;

	options->fifo_size = 0;
	options->xfer_count = 0;
	
	options->vcodec = EMhwlibVideoCodec_MPEG2;
	options->vcodec_profile = 0;
	options->vcodec_level = 0;
	options->vcodec_max_width = 0;
	options->vcodec_max_height = 0;
	options->vcodec_extra_pictures = 0;
	options->MSflag = FALSE;
	options->wmv9_seq = 0x4d491a01;
	options->auto_detect_codec = FALSE;
	
	options->input_scan_mode = EMhwlibScanMode_Source;
	options->display_error_threshold = 0;
	options->anchor_error_parms.AnchorErrPropagationThreshold = 500;
	options->anchor_error_parms.AnchorErrPropagationLength = 13;
	options->lowdelay = FALSE; /* used only for play_video */
	options->interlaced_progressive_algorithm = INTERLACED_PROGRESSIVE_ALGORITHM_USING_DECODER_SPECIFICATION;
	options->UseAFD = FALSE;  // parse and use Active Format Descriptor from stream
	options->ForceAFD = FALSE;  // force Active Format Descriptor for content
	options->AFDTransition = 0;  // Future extension: adjust display of several frames to new format
	options->afd.ActiveFormatValid = FALSE;
	options->afd.ActiveFormat = EMhwlibAF_same_as_picture;
	options->afd.FrameAspectRatio.X = 0;
	options->afd.FrameAspectRatio.Y = 0;
	
	options->first_pts_in_stream = 0;
	options->skipNCP = FALSE;

	return RM_OK;
}

RMstatus parse_video_cmdline(int argc, char **argv, int *index, struct video_cmdline *options)
{
	RMstatus err = RM_PENDING;
	int i = *index;

	if (RMCompareAscii(argv[i], "-seq")) {
		if (argc > i+1) {
			if (RMNCompareAscii(argv[i+1], "0x", 2) == TRUE) {
            	sscanf(argv[i+1], "0x%lx", &options->wmv9_seq);
			} else {
				options->wmv9_seq = strtol(argv[i+1], NULL, 10);
			}
			i+=2;
			err = RM_OK;
		}
		else {
			err = RM_ERROR;
		}
	}
	else if (RMCompareAscii(argv[i], "-ve")) {
		if (argc > i+1) {
			options->MpegEngineID = strtol(argv[i+1], NULL, 10);
			i+=2;
			err = RM_OK;
		}
		else {
			err = RM_ERROR;
		}
	} 
	else if ( ! strcmp(argv[i], "-vd")) {
		if (argc > i+1) {
			options->VideoDecoderID = strtol(argv[i+1], NULL, 10);
			i+=2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-2")) {
		options->MPEGProfile = Profile_MPEG2_HD;
		options->Codec = VideoDecoder_Codec_MPEG2_HD;
		i++;
		err = RM_OK;
	}
	else if (RMCompareAscii(argv[i], "-3")) {
		options->MPEGProfile = Profile_DIVX3_SD;
		options->Codec = VideoDecoder_Codec_DIVX3_SD;
		i++;

		err = RM_OK;
	}
	else if (RMCompareAscii(argv[i], "-4")) {
		options->MPEGProfile = Profile_MPEG4_SD;
		options->Codec = VideoDecoder_Codec_MPEG4_SD;
		i++;
		err = RM_OK;
	}
	else if (RMCompareAscii(argv[i], "-5")) {
		options->MPEGProfile = Profile_H264_SD;
		options->Codec = VideoDecoder_Codec_H264_SD;
		i++;
		err = RM_OK;
	}
	else if (RMCompareAscii(argv[i], "-9")) {
		options->MPEGProfile = Profile_WMV_816P;
		options->Codec = VideoDecoder_Codec_WMV_816P;
		i++;
		err = RM_OK;
	}
	else if (RMCompareAscii(argv[i], "-10")) {
		options->MPEGProfile = Profile_VC1_HD;
		options->Codec = VideoDecoder_Codec_VC1_HD;
		i++;
		err = RM_OK;
	}
	else if ((RMCompareAscii(argv[i], "-p")) || (RMCompareAscii(argv[i], "-v"))) {
		if (argc > i+1) {
			if (RMCompareAscii(argv[i], "-p")) {
				err = get_profile_profile(argv[i+1], &options->MPEGProfile);			
			}
			if (RMCompareAscii(argv[i], "-v")) {
				err = get_profile_codec(argv[i+1], &options->Codec);
			}
		}
		else
			err = RM_ERROR;
		
		if (err != RM_ERROR)
			err = RM_OK;
		i+=2;
	}
	else if (RMCompareAscii(argv[i], "-pv")) {
		if (argc > i+1) {
			if (RMCompareAscii(argv[i+1], "auto")) {
				options->auto_detect_codec = TRUE;
				RMDBGLOG((ENABLE, "\n\n\n\n\n********************** VIDEO CODEC: AUTO ***************\n\n\n\n"));
			}
			else {
				err = get_profile_profile(argv[i+1], &options->MPEGProfile);			
				
				err = get_profile_codec(argv[i+1], &options->Codec);
			}
		}
		else
			err = RM_ERROR;

		if (err != RM_ERROR)
			err = RM_OK;
		i+=2;
	}
	else if (RMCompareAscii(argv[i], "-fixvop")) {
		if (argc > i+2) {
			options->VopInfo.FixedVopRate = TRUE;
			RMasciiToUInt32(argv[i+1], &(options->VopInfo.VopTimeIncrementResolution));
			RMasciiToUInt32(argv[i+2], &(options->VopInfo.FixedVopTimeIncrement));
			i += 3;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-vtimescale")) {
		if (argc > i+1) {
			options->vtimescale.enable = TRUE;
			RMasciiToUInt32(argv[i+1], &(options->vtimescale.time_resolution));
			i += 2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-skipNCP")) {
		if (argc > i+1) {
			RMuint32 dummy;
			RMasciiToUInt32(argv[i+1], &dummy);

			if (dummy)
				options->skipNCP = TRUE;
			else
				options->skipNCP = FALSE;

			i += 2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-ics")) {
		if (argc > i+1) {
			if (RMCompareAsciiCaseInsensitively(argv[i+1], "none")) {
				options->input_color_space = EMhwlibColorSpace_None;
			// backwards compatibility
			} else if (RMCompareAscii(argv[i+1], "yuv_601")) {
				options->input_color_space = EMhwlibColorSpace_YUV_601;
			} else if (RMCompareAscii(argv[i+1], "yuv_709")) {
				options->input_color_space = EMhwlibColorSpace_YUV_709;
			} else if (RMCompareAscii(argv[i+1], "xv_601")) {
				options->input_color_space = EMhwlibColorSpace_xvYCC_601;
			} else if (RMCompareAscii(argv[i+1], "xv_709")) {
				options->input_color_space = EMhwlibColorSpace_xvYCC_709;
			} else if (RMCompareAscii(argv[i+1], "rgb_0_255")) {
				options->input_color_space = EMhwlibColorSpace_RGB_0_255;
			} else if (RMCompareAscii(argv[i+1], "rgb_16_235")) {
				options->input_color_space = EMhwlibColorSpace_RGB_16_235;
			// new notation
			} else if (RMCompareAsciiCaseInsensitively(argv[i+1], "YCC601")) {
				options->input_color_space = EMhwlibColorSpace_YUV_601;
			} else if (RMCompareAsciiCaseInsensitively(argv[i+1], "YCC601f")) {
				options->input_color_space = EMhwlibColorSpace_YUV_601_0_255;
			} else if (RMCompareAsciiCaseInsensitively(argv[i+1], "YCC709")) {
				options->input_color_space = EMhwlibColorSpace_YUV_709;
			} else if (RMCompareAsciiCaseInsensitively(argv[i+1], "YCC709f")) {
				options->input_color_space = EMhwlibColorSpace_YUV_709_0_255;
			} else if (RMCompareAsciiCaseInsensitively(argv[i+1], "xvYCC601")) {
				options->input_color_space = EMhwlibColorSpace_xvYCC_601;
			} else if (RMCompareAsciiCaseInsensitively(argv[i+1], "xvYCC601f")) {
				options->input_color_space = EMhwlibColorSpace_xvYCC_601_0_255;
			} else if (RMCompareAsciiCaseInsensitively(argv[i+1], "xvYCC709")) {
				options->input_color_space = EMhwlibColorSpace_xvYCC_709;
			} else if (RMCompareAsciiCaseInsensitively(argv[i+1], "xvYCC709f")) {
				options->input_color_space = EMhwlibColorSpace_xvYCC_709_0_255;
			} else if (RMCompareAsciiCaseInsensitively(argv[i+1], "RGB")) {
				options->input_color_space = EMhwlibColorSpace_RGB_0_255;
			} else if (RMCompareAsciiCaseInsensitively(argv[i+1], "RGBl")) {
				options->input_color_space = EMhwlibColorSpace_RGB_16_235;
			}
			else
				err = RM_ERROR;
			if (err != RM_ERROR) {
				err = RM_OK;
				options->force_input_color_space = TRUE;
			}
			i += 2;
		}
		else
			err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-ttx")) {
		options->display_ttx = TRUE; // ttx should be a playback option instead of video
		err = RM_OK;		     // put it here to be handled together with cc
		i++;
	}
	else if (RMCompareAscii(argv[i], "-cc")) {
		if (argc > i+1) {
			err = RM_OK;
			if(RMCompareAscii(argv[i+1], "tv")) {
				options->display_cc = TRUE;
				options->use_soft_cc_decoder = 0;
			}
			else if(RMCompareAscii(argv[i+1], "soft") || 
				RMCompareAscii(argv[i+1], "608soft") ||
				RMCompareAscii(argv[i+1], "cc1")) {
				options->display_cc = TRUE;
				options->use_soft_cc_decoder = 1;
				options->cc_select = EMhwlibCCSelect_CC1;
			}
			else if(RMCompareAscii(argv[i+1], "cc2") ){
				options->display_cc = TRUE;
				options->use_soft_cc_decoder = 1;
				options->cc_select = EMhwlibCCSelect_CC2;
			}
			else if(RMCompareAscii(argv[i+1], "cc3") ){
				options->display_cc = TRUE;
				options->use_soft_cc_decoder = 1;
				options->cc_select = EMhwlibCCSelect_CC3;
			}
			else if(RMCompareAscii(argv[i+1], "cc4") ){
				options->display_cc = TRUE;
				options->use_soft_cc_decoder = 1;
				options->cc_select = EMhwlibCCSelect_CC4;
			}
			else if(RMCompareAscii(argv[i+1], "708soft")) {
				options->display_cc = TRUE;
				options->use_soft_cc_decoder = 2;
			}
			else if(RMCompareAscii(argv[i+1], "off")) {
				options->display_cc = FALSE;
			}
			else