>* `Demuxer::Create`에서는 `mediademuxer_create`를 통해 demuxer를 생성하고, EoS(End of Stream)와 Error Event를 받기 위한 Callback 함수를 `mediademuxer_set_eos_cb`와 `mediademuxer_set_error_cb`로 각각 등록한다. 위 과정이 성공하면 demuxing할 file을 `mediademuxer_set_data_source`를 통해 설정하고 `mediademuxer_prepare` 함수를 통해 demuxer 상태를 MEDIADEMUXER_STATE_IDLE에서 MEDIADEMUXER_STATE_READY로 변경한다.

> ```{.c++}
void Demuxer::Create(const char* srcfilename)
{
	int ret = MEDIADEMUXER_ERROR_NONE;
	if((ret = mediademuxer_create(&m_demuxer)) != MEDIADEMUXER_ERROR_NONE)
		throw_error_and_destroy_demuxer(m_demuxer, "fail to create demuxer: ", ret);
	if((ret = mediademuxer_set_eos_cb(m_demuxer, demuxer_eos_cb, (void*)this)) != MEDIADEMUXER_ERROR_NONE)
		throw_error_and_destroy_demuxer(m_demuxer, "fail to mediademuxer_set_eos_cb: ", ret);
	if((ret = mediademuxer_set_error_cb(m_demuxer, demuxer_error_cb, (void*)this)) != MEDIADEMUXER_ERROR_NONE)
		throw_error_and_destroy_demuxer(m_demuxer, "fail to mediademuxer_set_error_cb: ", ret);
	if((ret = mediademuxer_set_data_source(m_demuxer, srcfilename)) != MEDIADEMUXER_ERROR_NONE)
		throw_error_and_destroy_demuxer(m_demuxer, "fail to mediademuxer_set_data_source: ", ret);
	if((ret = mediademuxer_prepare(m_demuxer)) != MEDIADEMUXER_ERROR_NONE)
		throw_error_and_destroy_demuxer(m_demuxer, "fail to mediademuxer_prepare: ", ret);	
}

>* demuxer가 _MEDIADEMUXER_STATE_READY_ 상태가 되면, 설정한 media file에 들어있는 track들에 대한 정보를 얻을 수 있다. `mediademuxer_get_track_count`를 통해서 track 개수를 얻을 수 있고, `mediademuxer_get_track_info`를 통해서 각 track의 media_format_h를 얻을 수 있다. 획득한 medai_format_h는 반드시 `media_format_unref`를 통해서 reference count를 줄여줘야 한다.

> ```{.c++}
void Demuxer::ExtractTrackinfo()
{
	int trackcount = 0;
	iferror_throw(mediademuxer_get_track_count(m_demuxer, &trackcount), "fail to mediademuxer_get_track_count: ");
	for(int i= 0; i < trackcount; ++i)
	{
		TrackForDemuxer track;
		iferror_throw(mediademuxer_get_track_info(m_demuxer, i, &track.info.fmt), "fail to mediademuxer_get_track_info: ");
		media_format_type_e formattype;
		int ret = MEDIA_FORMAT_ERROR_NONE;
		if((ret = media_format_get_type(track.info.fmt, &formattype))== MEDIA_FORMAT_ERROR_NONE)
		{
			switch(formattype)
			{
				case MEDIA_FORMAT_VIDEO:
					m_videotrackindex = i;
					m_tracks.push_back(track);
					break;
				case MEDIA_FORMAT_AUDIO:
					m_audiotrackindex = i;
					m_tracks.push_back(track);
					break;
				default:
					dlog_print(DLOG_ERROR, "Demuxer", "unsupportive type (%d)", (int)formattype);
					break;
			}
		}
		else
		{
			dlog_print(DLOG_ERROR, "Demuxer", "fail to media_format_get_type (%d)", ret);
		}
	}
}

>* _MEDIADEMUXER_STATE_RUNNING_ 상태에서는 선택한 track을 구성하는 packet들을 `mediademuxer_read_sample`를 통해 순차적으로 읽을 수 있다. 이때 주의할 점은 마지막 packet에 EOS flag가 설정되어 있지 않다는 것이다. 참고로 EOS callback은 마지막 packet을 읽고나면 발생한다. 마지막 packet에 EOS flag를 설정하고자 한다면 `media_packet_set_flags`를 통해서 설정 가능하다. 

> ```{.c++}
int Demuxer::read_sample(int track_index, media_packet_h* packet)
{
   *packet = NULL;
   return mediademuxer_read_sample(m_demuxer, track_index, packet);        
}

>* demuxer  사용이 완료되면 unprepare, destroy과정을 통해 사용했던 모든 자원을 반환한다.
> ```{.c++}
void Demuxer::Destroy()
{
	if(m_demuxer == NULL)
		return;
	for(int i= 0; i < m_tracks.size(); ++i)
	{
		if(m_tracks[i].info.fmt)
			media_format_unref(m_tracks[i].info.fmt);
	}
	m_tracks.clear();
	mediademuxer_unset_eos_cb(m_demuxer);
	mediademuxer_unset_error_cb(m_demuxer);
	//if ready state
	mediademuxer_unprepare(m_demuxer);
	mediademuxer_destroy(m_demuxer);
	m_demuxer = NULL;
}

>* Muxer또한 객체를 생성하는 것부터 시작한다. `Muxer::Create`에서는 `mediamuxer_create`를 통해 muxer를 생성하고, muxing 결과를 저장할 format과 파일 이름을 `mediamuxer_set_data_sink`로 설정한다. 여기서 주의할 점은 파일 이름을 local memory에 넣어서 넘겨주면 안된다는 것이다. Platform에서 별도 memory를 할당하지 않기 때문에 오동작이 일어나게 된다. Tizen3.0에서 지원하는 format은 아래와 같다.

> ```{.c++}
typedef enum {
	MEDIAMUXER_CONTAINER_FORMAT_MP4 = MEDIA_FORMAT_CONTAINER_MP4,	/**< The mediamuxer output format is MP4 container */
	MEDIAMUXER_CONTAINER_FORMAT_3GP = MEDIA_FORMAT_CONTAINER_3GP,	/**< The mediamuxer output format is 3GP container */
	MEDIAMUXER_CONTAINER_FORMAT_WAV = MEDIA_FORMAT_CONTAINER_WAV,	/**< The mediamuxer output format is WAV container */
	MEDIAMUXER_CONTAINER_FORMAT_AMR_NB = MEDIA_FORMAT_AMR_NB,	/**< The mediamuxer output format is ARM_NB container */
	MEDIAMUXER_CONTAINER_FORMAT_AMR_WB = MEDIA_FORMAT_AMR_WB,	/**< The mediamuxer output format is AMR_WB container */
	MEDIAMUXER_CONTAINER_FORMAT_AAC_ADTS = MEDIA_FORMAT_CONTAINER_AAC_ADTS	/**< The mediamuxer output format is AAC_ADTS container */
} mediamuxer_output_format_e;

>* Muxer 생성에 성공하면 `mediamuxer_add_track`을 통해 video/audio track을 추가하고 track의 format 정보를 알려줘야 한다. format 정보는 `media_format`함수들을 통해서 아래와 같이 만들 수 있다. 본 sample app에서는 video/audio encoder에서 format을 생성하여 제공한다.   

> ```{.c++}
//note that you should add error handling codes for each media_format function calls
media_format_h video_fmt;
int ret = media_format_create(&video_fmt);
ret = media_format_set_video_mime(video_fmt, MEDIA_FORMAT_H264_SP);	
ret = media_format_set_video_width(video_fmt, 640);
ret = media_format_set_video_height(video_fmt, 480);
ret = media_format_set_video_avg_bps(video_fmt, 256000);
ret = media_format_set_video_max_bps(video_fmt, 256000);

>* track이 성공적으로 추가되었다면 muxing을 시작할 수 있다. `mediamuxer_prepare`로 _MEDIA_MUXER_READY_STATE_ 로 만들고 바로 `mediamuxer_start`로 _RUNNING_ 상태를 만들자. Media Demuxer와 다르게 Muxer에서는 _MEDIA_MUXER_READY_STATE_ 에서 할 수 있는 작업이 start외에는 없다. `mediamuxer_prepare`성공했다면 바로 `mediamuxer_start`를 호출하면 되겠다.

> ```{.c++}
void Muxer::Start()
{
	iferror_throw(mediamuxer_prepare(m_muxer), "fail to mediamuxer_prepare");
	int ret = MEDIAMUXER_ERROR_NONE;
	if((ret = mediamuxer_start(m_muxer))!= MEDIAMUXER_ERROR_NONE)
	{
		mediamuxer_unprepare(m_muxer);
		m_muxer = NULL;
		throw std::runtime_error("fail to mediamuxer_start");
	}
}

>* packet write 가 완료되면 생성 순서와 역순으로 resource를 정리해야 한다. `mediamuxer_stop`-> `mediamuxer_unprepare` -> `mediamuxer_destroy`


* Codec 구현

> [codecbase.h](https://github.com/hereforu/tizen-multimedia-apps/blob/master/transcoder/inc/codecbase.h)
> [codecbase.cpp](https://github.com/hereforu/tizen-multimedia-apps/blob/master/transcoder/src/codecbase.cpp)

> [videodecoder.h](https://github.com/hereforu/tizen-multimedia-apps/blob/master/transcoder/inc/videodecoder.h)
> [videodecoder.cpp](https://github.com/hereforu/tizen-multimedia-apps/blob/master/transcoder/src/videodecoder.cpp)

> [videoencoder.h](https://github.com/hereforu/tizen-multimedia-apps/blob/master/transcoder/inc/videoencoder.h)
> [videoencoder.cpp](https://github.com/hereforu/tizen-multimedia-apps/blob/master/transcoder/src/videoencoder.cpp)

> [audiodecoder.h](https://github.com/hereforu/tizen-multimedia-apps/blob/master/transcoder/inc/audiodecoder.h)
> [audiodecoder.cpp](https://github.com/hereforu/tizen-multimedia-apps/blob/master/transcoder/src/audiodecoder.cpp)

> [audioencoder.h](https://github.com/hereforu/tizen-multimedia-apps/blob/master/transcoder/inc/audioencoder.h)
> [audioencoder.cpp](https://github.com/hereforu/tizen-multimedia-apps/blob/master/transcoder/src/audioencoder.cpp)

>* Codec은 [tizen media codec](https://developer.tizen.org/development/api-references/native-application?redirect=/dev-guide/2.3.1/org.tizen.native.mobile.apireference/group__CAPI__MEDIA__CODEC__MODULE.html)을 활용하여 구현되었으며 아래 그림과 같이 CodecBase를 base class로 하여 video/audio encoder/decoder를 만드는 구조로 구현하였다.

> ![codec structure](https://github.com/hereforu/tizen-multimedia-apps/blob/master/Wiki_Images/codec_structure.png)

> ```{.c++}
class CodecBase
{
public:
	CodecBase();
	virtual ~CodecBase();
	void Create(const CodecInfo& codecinfo);
	void Destroy();
	bool GetPacket(media_packet_h& packet);
	bool InsertPacket(media_packet_h packet);
	bool IsEoS();
        ...
};

> ```{.c++}
typedef struct _VDecInfo
{
	mediacodec_codec_type_e codecid;
	int width;
	int height;
}VDecInfo;
typedef struct _VEncInfo
{
	mediacodec_codec_type_e codecid;
	int width;
	int height;
	int fps;
	int target_bits;
}VEncInfo;
typedef struct _ADecInfo
{
	mediacodec_codec_type_e codecid;
	int samplerate;
	int channel;
	int bit;
}ADecInfo;
typedef struct _AEncInfo
{
	mediacodec_codec_type_e codecid;
	int samplerate;
	int channel;
	int bit;
	int bitrate;
}AEncInfo;
typedef union _CodecInfo
{
	VDecInfo vdec;
	VEncInfo venc;
	ADecInfo adec;
	AEncInfo aenc;
}CodecInfo;
void CodecBase::Create(const CodecInfo& codecinfo)
{
	iferror_throw(mediacodec_create(&m_mediacodec), "fail to create mediacodec_create");
	if(create(m_mediacodec, codecinfo) == false)//this function should be defined in each derived class
		throw_error_and_destroy_codec(m_mediacodec, "fail to create specific codec", 0)
	int ret = MEDIACODEC_ERROR_NONE;
	if((ret = mediacodec_set_eos_cb(m_mediacodec, mc_eos_cb, (void*)this)) != MEDIACODEC_ERROR_NONE)
		throw_error_and_destroy_codec(m_mediacodec, "fail to mediacodec_set_eos_cb", ret);
	if((ret = mediacodec_set_error_cb(m_mediacodec, mc_error_cb, (void*)this)) != MEDIACODEC_ERROR_NONE)
		throw_error_and_destroy_codec(m_mediacodec, "fail to mediacodec_set_error_cb", ret);
	if((ret = mediacodec_set_input_buffer_used_cb(m_mediacodec, mc_input_buffer_used_cb, (void*)this)) != MEDIACODEC_ERROR_NONE)
		throw_error_and_destroy_codec(m_mediacodec, "fail to mediacodec_set_input_buffer_used_cb", ret);
	if((ret = mediacodec_set_output_buffer_available_cb(m_mediacodec, mc_output_buffer_available_cb, (void*)this)) != MEDIACODEC_ERROR_NONE)
		throw_error_and_destroy_codec(m_mediacodec, "fail to mediacodec_set_output_buffer_available_cb", ret);
	if((ret = mediacodec_prepare(m_mediacodec)) != MEDIACODEC_ERROR_NONE)
		throw_error_and_destroy_codec(m_mediacodec, "fail to mediacodec_prepare", ret);
}

>* encoding/decoding할 packet을 순서대로 밀어 넣는다.

> ```{.c++}
bool CodecBase::InsertPacket(media_packet_h packet)
{
	int ret = mediacodec_process_input(m_mediacodec, packet, 1000);
	if(ret != MEDIACODEC_ERROR_NONE)
	{
		dlog_print(DLOG_ERROR, "CodecBase", "fail to mediacodec_process_input %d [%s]", ret, getname());
		return false;
	}
	return true;
}

>> `mc_output_buffer_available_cb`는 결과 packet이 만들어지면 호출된다. packet을 획듣하여 적절한 처리를 하면 된다. 본 sample code에서는 output queue를 두어 queue에 결과 파일을 insert한다. 

>> ```{.c++}
void CodecBase::handle_output_buffer_available(media_packet_h pkt)
{
	media_packet_h output_buf = NULL;
	int ret = mediacodec_get_output(m_mediacodec, &output_buf, 0);
	if(ret != MEDIACODEC_ERROR_NONE)
	{
		dlog_print(DLOG_ERROR, "CodecBase", "fail to mediacodec_get_output %d [%s]", ret, getname());
	}
	pushpacket_to_outputqueue(output_buf);
}
//callback function
void CodecBase::mc_output_buffer_available_cb(media_packet_h pkt, void *user_data)
{
	CodecBase* codec = (CodecBase*)user_data;
	codec->handle_output_buffer_available(pkt);
}

>* TranscodingEngine class는 지금까지 설명한 demuxer, muxer, codec, 그리고 image transform 기능을 모두 사용하지만 외부에 Transcoding과 Cancel만 제공한다.
>* Transcoding을 시작하기 위해서는 transcoding할 파일 이름 `srcfilename`과 video/audio encoder 정보인 `CodecInfo venc/aenc`를 설정해야 한다. video/audio encoder 정보는 다음과 같다.
> ```{.c++}
typedef struct _VEncInfo
{
	mediacodec_codec_type_e codecid;
	int width;
	int height;
	int fps;
	int target_bits;
}VEncInfo;
typedef struct _AEncInfo
{
	mediacodec_codec_type_e codecid;
	int samplerate;
	int channel;
	int bit;
	int bitrate;
}AEncInfo;

>>* `generatedstfilename` 함수는 source 파일 이름의 마지막에 _trans를 붙여 source 파일과 같은 폴더에 결과 파일이 만들어질 수 있도록 생성한다. 만일 동일 파일이 이미 존재하면 _trans뒤로 일련 번호를 붙이도록 작성하였다.
>>* `create_demuxer`는 이미 설명한 demuxer 객체를 생성하여 멤버 변수에 할당하는 함수이다. 생성 중간에 exception이 발생해도 memory leak이 발생하지 않도록 auto_ptr로 생성한다. exception이 발생하지 않으면 auto_ptr을 해제하고 생성된 객체를 member 변수에 할당하여 생성을 완료한다. 

>> ```{.c++}
void TranscodingEngine::create_demuxer(const char* srcfilename)
{
	std::auto_ptr<Demuxer> demuxer(new Demuxer);
	demuxer->Create(srcfilename);
	demuxer->ExtractTrackinfo();
	m_demuxer = demuxer.release();
}

>> ```{.c++}
void TranscodingEngine::create_muxer(const char* srcfilename)
{
	std::auto_ptr<Muxer> muxer(new Muxer);
	muxer->Create(generatedstfilename(srcfilename), MEDIAMUXER_CONTAINER_FORMAT_MP4);
	m_muxer_video_track_index = muxer->AddTrack(m_codec[VIDEO_ENCODER]->GetMediaFormat());
	m_muxer_audio_track_index = muxer->AddTrack(m_codec[AUDIO_ENCODER]->GetMediaFormat());
	m_muxer = muxer.release();
}

>* 필요 객체 준비가 완료되면 demuxer와 muxer를 start 시키고 transcoding을 진행한다. 모든 packet에 대한 처리가 끝나면 muxer와 demuxer를 stop하고 transcoding을 완료한다.

> ```{.c++}
void TranscodingEngine::Transcoding(const char* srcfilename, unsigned int duration, const CodecInfo& venc, const CodecInfo& aenc)
{
	device_power_request_lock(POWER_LOCK_CPU, 0);
	prepare(srcfilename, duration, venc, aenc);
	m_demuxer->Start();
	m_muxer->Start();
	transcoding();
	m_muxer->Stop();
	m_demuxer->Stop();
	unprepare();
	device_power_release_lock(POWER_LOCK_CPU);
}

>>* 각 track에 대한 처리는 아래와 같이 진행된다.

>>>* `feed_decoder_with_packet`: demuxer로부터 encoded packet을 읽어와 decoder의 input queue에 넣어준다.

>>> ```{.c++}
bool TranscodingEngine::feed_decoder_with_packet(CodecBase* decoder, int track_index, int& count, unsigned int& pts)
{
	media_packet_h demux_packet = NULL;
	if(m_demuxer->IsEoS(track_index) == true)
		return true;
	if(m_demuxer->ReadSeample(track_index, &demux_packet))
	{
		++count;
		pts = get_pts_in_msec(demux_packet);
		dlog_print(DLOG_DEBUG, "TranscodingEngine", "%dth demuxed packet [pts:%u]", count, pts);
		if(!decoder->InsertPacket(demux_packet))
		{
			dlog_print(DLOG_ERROR, "TranscodingEngine", "while putting the %d th packet to the decoder", count);
			return false;
		}
	}
	return true;
}

>>>* `feed_muxer_with_packet`: encoder로부터 encoding된 packet을 읽어와 muxer를 통해 write한다. 

>>> ```{.c++}
bool TranscodingEngine::feed_muxer_with_packet(CodecBase* encoder, int muxer_track_index, int& count)
{
	bool bret = true;
	if(encoder == NULL)
		return false;
	media_packet_h encoded_packet;
	if(encoder->IsEoS()==false)
	{
		if(encoder->GetPacket(encoded_packet))
		{
			++count;
			bret = m_muxer->WriteSample(muxer_track_index, encoded_packet);
			media_packet_destroy(encoded_packet);
			dlog_print(DLOG_DEBUG, "TranscodingEngine", "%dth encoded packet", count);
		}
	}
	return bret;
}