rmasfdemux.cpp

Sigma SMP8634 Mrua v. 2.8.2.0

		RMDBGLOG((LOCALDBG, "\tAspectRatio\n"));
	}

}


void RMasfdemux::Init (void * context)
{
	RMDBGLOG((ENABLE, "init demux, application's context @0x%08X\n", context));
	if(m_asf_demux_state) {
		asf_demux_init ((struct asf_demux_state_t *)m_asf_demux_state, m_localContext);
		m_context = context;
		m_isIndexConstructed = FALSE;
	}	
}
	
void RMasfdemux::SetStreamingBehavior ()
{
	RMDBGLOG((ENABLE, "Set streaming behavior\n"));
	if(m_asf_demux_state) {
		asf_demux_set_streaming_behavior ((struct asf_demux_state_t *)m_asf_demux_state);
	}	
}
	
void RMasfdemux::Reset (void * context)
{
	RMDBGLOG((ENABLE, "reset demux, context @0x%08X\n", context));
	if(m_asf_demux_state) {
		asf_demux_init ((struct asf_demux_state_t *)m_asf_demux_state, m_localContext);

		RMDBGLOG((ENABLE, "re-registering local callbacks...\n"));

		RegisterCallbacks();

	}
}

void RMasfdemux::ResetState (void)
{
	asf_demux_reset((struct asf_demux_state_t *)m_asf_demux_state);
}

void RMasfdemux::ResetStateWithPacket(RMuint32 packet)
{
	RMDBGLOG((DISABLE, "resetStateWithPacket(%lu)\n", packet));
	asf_demux_reset_packet((struct asf_demux_state_t *)m_asf_demux_state, packet);
}


void RMasfdemux::Demux (RMuint8 *buffer, RMuint32 length)
{
	if(m_asf_demux_state) {
		asf_demux((struct asf_demux_state_t *)m_asf_demux_state, buffer, (RMuint64)length);
	}
}

#define INDEX_BUFFER_SIZE (200 * 1024)

RMstatus RMasfdemux::ConstructIndex (RMnonAscii *fileName, RMuint32 *packetSize, RMuint64 *header_size)
{
	RMuint64 Header_Object_Size = 0, Data_Object_Size = 0;
	RMuint32 Minimum_Data_Packet_Size = 0, Maximum_Data_Packet_Size = 0;
	RMfile f;
	RMuint32 readSize;
	RMstatus status = RM_OK;
	RMuint32 currentCallbackMask;

	RMuint8 *hackbuffer = (RMuint8*)NULL;


	if(fileName == (RMnonAscii *)NULL){
		RMDBGLOG((ENABLE,"Error : no file specified\n"));
		return RM_ERROR;
	}

	if(m_isIndexConstructed) {
		*packetSize = m_packetSize;
		*header_size = m_header_Object_Size;
		return RM_OK;
	}

	RMDBGLOG((ASFDEMUXDBG,"Constructing ASF index ...\n"));

	// save current mask
	currentCallbackMask = m_activeCallbacks;

	DeactivateCallbacks(PAYLOAD_CB);

	f = RMOpenFile(fileName, RM_FILE_OPEN_READ);
	if (f == (RMfile)NULL){
		RMDBGLOG((ENABLE,"Error, cannot open %s\n", fileName));
		status = RM_ERROR;
		goto finish;
	}

	hackbuffer = (RMuint8 *)RMMalloc(INDEX_BUFFER_SIZE);
	if (hackbuffer == NULL) {
		RMDBGLOG((ENABLE, "not enough memory for index construction!\n"));
		m_isIndexConstructed = FALSE;
		m_isThereAnIndex = FALSE;
		status = RM_ASF_WITHOUT_INDEX;
		goto finish;
	}

	//Reset(m_context);


	while (RMReadFile (f, hackbuffer, INDEX_BUFFER_SIZE, &readSize) == RM_OK){
		RMuint32 rc;

		rc = asf_demux((struct asf_demux_state_t *)m_asf_demux_state, hackbuffer, (RMuint64)readSize);

		RMDBGLOG((ENABLE, "rc = %ld\n", rc));
		
		if (asf_demux_finished_parsing_header((struct asf_demux_state_t *)m_asf_demux_state)) {
			RMDBGLOG((ENABLE, "break\n"));
			break;
		}
			

		
	}
	
	if((asf_demux_get_header_objects_size((struct asf_demux_state_t *)m_asf_demux_state) != 0) &&
	   (asf_demux_get_min_packet_size_info((struct asf_demux_state_t *)m_asf_demux_state)!= 0) &&
	   (asf_demux_get_max_packet_size_info((struct asf_demux_state_t *)m_asf_demux_state) != 0)) {
		
		Minimum_Data_Packet_Size = asf_demux_get_min_packet_size_info((struct asf_demux_state_t *)m_asf_demux_state);
		Maximum_Data_Packet_Size = asf_demux_get_max_packet_size_info((struct asf_demux_state_t *)m_asf_demux_state);
		Header_Object_Size = asf_demux_get_header_objects_size((struct asf_demux_state_t *)m_asf_demux_state);
		RMDBGLOG((ENABLE,"Header info found : header size = %llu, min packet size = %lu, max = %lu\n", 
			  Header_Object_Size,
			  Minimum_Data_Packet_Size,
			  Maximum_Data_Packet_Size));
	}
	else {
		RMDBGLOG((ENABLE, "couldnt find header!\n"));
		status = RM_ERROR;
		goto finish;
	}
	
	if(Minimum_Data_Packet_Size != Maximum_Data_Packet_Size){
		RMDBGLOG((ENABLE,"ERROR : Minimum_Data_Packet_Size != Maximum_Data_Packet_Size\n"));
		status = RM_ERROR;
		goto finish;
	}	
	
	*packetSize = Maximum_Data_Packet_Size;
     	m_packetSize = Maximum_Data_Packet_Size;
	*header_size = Header_Object_Size;
	m_header_Object_Size = Header_Object_Size;

	RMDBGLOG((ENABLE,"///////////////////// m_header_Object_Size = %lu\n", m_header_Object_Size));
	RMDBGLOG((ENABLE,"///////////////////// m_packetSize = %lu\n", m_packetSize));

	if( asf_demux_get_data_objects_size((struct asf_demux_state_t *)m_asf_demux_state) == 0) {
		RMSeekFile (f, Header_Object_Size, RM_FILE_SEEK_START);
		asf_demux_set_position_in_file ((struct asf_demux_state_t *)m_asf_demux_state, Header_Object_Size);
		
		while (RMReadFile (f, hackbuffer, INDEX_BUFFER_SIZE, &readSize) == RM_OK){
			asf_demux((struct asf_demux_state_t *)m_asf_demux_state, hackbuffer, (RMuint64)readSize);
			if( asf_demux_get_data_objects_size((struct asf_demux_state_t *)m_asf_demux_state) != 0) {
				Data_Object_Size = asf_demux_get_data_objects_size((struct asf_demux_state_t *)m_asf_demux_state);
				RMDBGLOG((ASFDEMUXDBG,"Data Header info found : header size = %llu\n", 
					  Data_Object_Size));
				break;
			}
		}
	}
	else
		Data_Object_Size = asf_demux_get_data_objects_size((struct asf_demux_state_t *)m_asf_demux_state);

	if(asf_demux_init_index_construction((struct asf_demux_state_t *)m_asf_demux_state) < 0){
		RMDBGLOG((ENABLE,"Cannot init index construction\n"));
		status = RM_ERROR;
		goto finish;
	}	

	if(f == (RMfile)NULL) {
		RMDBGLOG((ENABLE, "Cannot open file \"%s\"\n", (RMascii*)fileName));
		status = RM_ERROR;
		goto finish;
	}

	status = RMSeekFile (f, Header_Object_Size+Data_Object_Size, RM_FILE_SEEK_START);
	if (status != RM_OK) {
		RMDBGLOG((ENABLE, "seek failed!!, abort index construction\n"));
		m_isIndexConstructed = FALSE;
		m_isThereAnIndex = FALSE;
		status = RM_ASF_WITHOUT_INDEX;
		goto finish;
	}
	asf_demux_set_position_in_file ((struct asf_demux_state_t *)m_asf_demux_state, Header_Object_Size+Data_Object_Size);

	while (RMReadFile (f, hackbuffer, INDEX_BUFFER_SIZE, &readSize) == RM_OK){
		RMDBGLOG((ASFDEMUXDBG,"Sending %lu of data to index construct\n", readSize));
		
		if(asf_demux_construct_index((struct asf_demux_state_t *)m_asf_demux_state,
					     hackbuffer,
					     readSize) < 0) {
			RMDBGLOG((ENABLE,"ERROR in construct index\n"));
			break;
		}
	}

	if (m_isThereAnIndex) {
		m_isIndexConstructed = TRUE;

		RMDBGLOG((ASFDEMUXDBG,"... success\n"));

		if (m_localIndex)
			RMDBGLOG((ENABLE, ">>> Index is local\n"));
		else
			RMDBGLOG((ENABLE, ">>> Index is not local\n"));
		
		status = RM_OK;
	}
	else {
		m_isIndexConstructed = FALSE;

		RMDBGLOG((ASFDEMUXDBG,"... failure (or no index?)\n"));

		status = RM_ERROR;
	}
 finish:
	if (f)
		RMCloseFile(f);
	//Reset (m_context);

	// reactivate enabled callbacks
	ActivateCallbacks(currentCallbackMask);

	if (hackbuffer != NULL) {
		RMFree(hackbuffer);
		hackbuffer = (RMuint8*)NULL;
	}

	return status;
}


RMstatus RMasfdemux::ConstructIndexWithHandle (RMfile filehandle, RMuint32 *packetSize, RMuint64 *header_size)
{
	RMuint64 Header_Object_Size = 0, Data_Object_Size = 0;
	RMuint32 Minimum_Data_Packet_Size = 0, Maximum_Data_Packet_Size = 0;
	RMint64 currentpos = 0;
	RMuint32 readSize;
	RMstatus status;
	RMuint32 currentCallbackMask;

	RMuint8 *hackbuffer;

	if(filehandle == NULL){
		RMDBGLOG((ENABLE,"Error : no file specified\n"));
		return RM_ERROR;
	}

	if(m_isIndexConstructed) {
		*packetSize = m_packetSize;
		*header_size = m_header_Object_Size;
		return RM_OK;
	}

	RMDBGLOG((ASFDEMUXDBG,"Constructing ASF index ...\n"));

	// save current mask
	currentCallbackMask = m_activeCallbacks;

	DeactivateCallbacks(PAYLOAD_CB);

	hackbuffer = (RMuint8 *)RMMalloc(INDEX_BUFFER_SIZE);
	if (hackbuffer == NULL) {
		RMDBGLOG((ENABLE, "not enough memory for index construction!\n"));
		m_isIndexConstructed = FALSE;
		m_isThereAnIndex = FALSE;
		status = RM_ASF_WITHOUT_INDEX;
		goto finish;
	}

	//Reset(m_context);

	RMGetCurrentPositionOfFile(filehandle, &currentpos);
	RMDBGLOG((ENABLE, "current pos %llu\n", currentpos));

	status = RMSizeOfOpenFile(filehandle, &m_realFileSize);
	if (status != RM_OK)
		RMDBGLOG((ENABLE, "*** cant get real file size\n"));
	else
		RMDBGLOG((ENABLE, ">> real file size %llu\n", m_realFileSize));

	RMSeekFile(filehandle, 0, RM_FILE_SEEK_START);

	while (RMReadFile (filehandle, hackbuffer, INDEX_BUFFER_SIZE, &readSize) == RM_OK){
		RMuint32 rc;

		rc = asf_demux((struct asf_demux_state_t *)m_asf_demux_state, hackbuffer, (RMuint64)readSize);

		RMDBGLOG((ENABLE, "rc = %ld\n", rc));
		
		if (asf_demux_finished_parsing_header((struct asf_demux_state_t *)m_asf_demux_state)) {
			RMDBGLOG((ENABLE, "break\n"));
			break;
		}
			

		
	}
	
	if((asf_demux_get_header_objects_size((struct asf_demux_state_t *)m_asf_demux_state) != 0) &&
	   (asf_demux_get_min_packet_size_info((struct asf_demux_state_t *)m_asf_demux_state)!= 0) &&
	   (asf_demux_get_max_packet_size_info((struct asf_demux_state_t *)m_asf_demux_state) != 0)) {
		
		Minimum_Data_Packet_Size = asf_demux_get_min_packet_size_info((struct asf_demux_state_t *)m_asf_demux_state);
		Maximum_Data_Packet_Size = asf_demux_get_max_packet_size_info((struct asf_demux_state_t *)m_asf_demux_state);
		Header_Object_Size = asf_demux_get_header_objects_size((struct asf_demux_state_t *)m_asf_demux_state);
		RMDBGLOG((ENABLE,"Header info found : header size = %llu, min packet size = %lu, max = %lu\n", 
			  Header_Object_Size,
			  Minimum_Data_Packet_Size,
			  Maximum_Data_Packet_Size));
	}
	else {
		RMDBGLOG((ENABLE, "couldnt find header!\n"));
		status = RM_ERROR;
		goto finish;
	}

	if(Minimum_Data_Packet_Size != Maximum_Data_Packet_Size){
		RMDBGLOG((ENABLE,"ERROR : Minimum_Data_Packet_Size != Maximum_Data_Packet_Size\n"));
		status = RM_ERROR;
		goto finish;
	}	
	
	*packetSize = Maximum_Data_Packet_Size;
     	m_packetSize = Maximum_Data_Packet_Size;
	*header_size = Header_Object_Size;
	m_header_Object_Size = Header_Object_Size;

	RMDBGLOG((ENABLE,"///////////////////// m_header_Object_Size = %llu\n", m_header_Object_Size));
	RMDBGLOG((ENABLE,"///////////////////// m_packetSize = %lu\n", m_packetSize));

	if( asf_demux_get_data_objects_size((struct asf_demux_state_t *)m_asf_demux_state) == 0) {
		RMSeekFile (filehandle, Header_Object_Size, RM_FILE_SEEK_START);
		asf_demux_set_position_in_file ((struct asf_demux_state_t *)m_asf_demux_state, Header_Object_Size);
		
		while (RMReadFile (filehandle, hackbuffer, INDEX_BUFFER_SIZE, &readSize) == RM_OK){
			asf_demux((struct asf_demux_state_t *)m_asf_demux_state, hackbuffer, (RMuint64)readSize);
			if( asf_demux_get_data_objects_size((struct asf_demux_state_t *)m_asf_demux_state) != 0) {
				Data_Object_Size = asf_demux_get_data_objects_size((struct asf_demux_state_t *)m_asf_demux_state);
				RMDBGLOG((ASFDEMUXDBG,"Data Header info found : header size = %llu\n", 
					  Data_Object_Size));
				break;
			}
		}
	}
	else
		Data_Object_Size = asf_demux_get_data_objects_size((struct asf_demux_state_t *)m_asf_demux_state);

	RMDBGLOG((ENABLE,"///////////////////// dataObjectSize = %llu\n", Data_Object_Size));

	if ((m_Broadcast) || (!m_isFileSeekable)) {
		RMDBGLOG((ENABLE, "////// file has broadcast flag or is not seekable, abort index construction\n"));
		m_isIndexConstructed = FALSE;
		m_isThereAnIndex = FALSE;
		status = RM_ASF_WITHOUT_INDEX;
		goto finish;
	}
		
	if(asf_demux_init_index_construction((struct asf_demux_state_t *)m_asf_demux_state) < 0){
		RMDBGLOG((ENABLE,"Cannot init index construction\n"));
		status = RM_ERROR;
		goto finish;
	}	

	status = RMSeekFile (filehandle, Header_Object_Size+Data_Object_Size, RM_FILE_SEEK_START);
	if (status != RM_OK) {
		RMDBGLOG((ENABLE, "seek failed!!, abort index construction\n"));
		m_isIndexConstructed = FALSE;
		m_isThereAnIndex = FALSE;
		status = RM_ASF_WITHOUT_INDEX;
		goto finish;
	}
	asf_demux_set_position_in_file ((struct asf_demux_state_t *)m_asf_demux_state, Header_Object_Size+Data_Object_Size);

	while (RMReadFile (filehandle, hackbuffer, INDEX_BUFFER_SIZE, &readSize) == RM_OK){
		RMDBGLOG((ENABLE,"Sending %lu of data to index construct\n", readSize));
		
		if(asf_demux_construct_index((struct asf_demux_state_t *)m_asf_demux_state,
					     hackbuffer,
					     readSize) < 0) {
			RMDBGLOG((ENABLE,"ERROR in construct index\n"));
			break;
		}
	}

	if (m_isThereAnIndex) {
		m_isIndexConstructed = TRUE;

		RMDBGLOG((ASFDEMUXDBG,"... success\n"));

		if (m_localIndex)
			RMDBGLOG((ENABLE, ">>> Index is local\n"));
		else
			RMDBGLOG((ENABLE, ">>> Index is not local\n"));
		
		status = RM_OK;
	}
	else {
		m_isIndexConstructed = FALSE;

		RMDBGLOG((ASFDEMUXDBG,"... failure (or no index?)\n"));

		if ((m_audioStreamFound) && (!m_videoStreamFound)) {
			RMDBGLOG((ENABLE, ">> audio only file, enable alternate seek\n"));
			m_isAudioOnly = TRUE;
		}
		status = RM_ASF_WITHOUT_INDEX;
	}
 finish:
	RMDBGLOG((ENABLE, "seeking to %llu\n", currentpos));
	RMSeekFile (filehandle, currentpos, RM_FILE_SEEK_START);

	// reactivate enabled callbacks
	ActivateCallbacks(currentCallbackMask);

	if (hackbuffer != NULL) {
		RMFree(hackbuffer);
		hackbuffer = (RMuint8*)NULL;
	}

	return status;