testRTSPClient.cpp

#include "textRTCPClient.h"

// A function that outputs a string that identifies each stream (for debugging output).  Modify this if you wish:
UsageEnvironment& operator<<(UsageEnvironment& env, const RTSPClient& rtspClient) {
  return env << "[URL:\"" << rtspClient.url() << "\"]: ";
}

// A function that outputs a string that identifies each subsession (for debugging output).  Modify this if you wish:
UsageEnvironment& operator<<(UsageEnvironment& env, const MediaSubsession& subsession) {
  return env << subsession.mediumName() << "/" << subsession.codecName();
}

void usage(UsageEnvironment& env, char const* progName) {
  env << "Usage: " << progName << " <rtsp-url-1> ... <rtsp-url-N>\n";
  env << "\t(where each <rtsp-url-i> is a \"rtsp://\" URL)\n";
}

void FFmepgInit()
{
	av_register_all();
	av_register_all();
	pstructData->p_codec=avcodec_find_decoder(AV_CODEC_ID_H264);
	pstructData->p_codec_ctx=avcodec_alloc_context3(pstructData->p_codec);
	
	if(ret>=0){
		pstructData->p_frm_raw=av_frame_alloc();
		pstructData->p_frm_yuv=av_frame_alloc();
	}


	ret = avcodec_open2(pstructData->p_codec_ctx, pstructData->p_codec, NULL);
	pstructData->p_CodecParserCtx=av_parser_init(AV_CODEC_ID_H264);
}

void SDLInit()
{
	if(SDL_Init(SDL_INIT_VIDEO| SDL_INIT_AUDIO|SDL_INIT_TIMER))
	{
		printf("SDL_Init() failed: %s\n",SDL_GetError());
		return;
	}
	pstructData->screen =SDL_CreateWindow("player Window",
											SDL_WINDOWPOS_UNDEFINED,
											SDL_WINDOWPOS_UNDEFINED,
											384,
											288,
											SDL_WINDOW_OPENGL);
	if(pstructData->screen== NULL)
	{
		printf("SDL:: could not create Window -exiting:%s\n",SDL_GetError());
	}
	pstructData->sdl_renderer=SDL_CreateRenderer(pstructData->screen,-1,0);
	int pixformat=SDL_PIXELFORMAT_IYUV;
	pstructData->sdl_texture=SDL_CreateTexture(pstructData->sdl_renderer,pixformat,SDL_TEXTUREACCESS_STREAMING,384,288);
	pstructData->sdl_rect.x=0;
	pstructData->sdl_rect.y=0;
	pstructData->sdl_rect.w=384;
	pstructData->sdl_rect.h=288;
}

int SDLThread(void *data)
{
	//structData *pstructData=(structData*)SDLdata;
	while (thread_exit==0)
	{
		SDL_Event event;
		event.type=REFRESH_EVENT;
		SDL_PushEvent(&event);
		SDL_Delay(40);
	}
	thread_exit=0;
	return 0;
}

void openURL(UsageEnvironment& env, char const* progName, char const* rtspURL) {
  // Begin by creating a "RTSPClient" object.  Note that there is a separate "RTSPClient" object for each stream that we wish
  // to receive (even if more than stream uses the same "rtsp://" URL).
  RTSPClient* rtspClient = ourRTSPClient::createNew(env, rtspURL, RTSP_CLIENT_VERBOSITY_LEVEL, progName);
  if (rtspClient == NULL) {
    env << "Failed to create a RTSP client for URL \"" << rtspURL << "\": " << env.getResultMsg() << "\n";
    return;
  }

  ++rtspClientCount;

  // Next, send a RTSP "DESCRIBE" command, to get a SDP description for the stream.
  // Note that this command - like all RTSP commands - is sent asynchronously; we do not block, waiting for a response.
  // Instead, the following function call returns immediately, and we handle the RTSP response later, from within the event loop:
  rtspClient->sendDescribeCommand(continueAfterDESCRIBE); 
}

void continueAfterDESCRIBE(RTSPClient* rtspClient, int resultCode, char* resultString) {
  do {
    UsageEnvironment& env = rtspClient->envir(); // alias
    StreamClientState& scs = ((ourRTSPClient*)rtspClient)->scs; // alias

    if (resultCode != 0) {
      env << *rtspClient << "Failed to get a SDP description: " << resultString << "\n";
      delete[] resultString;
      break;
    }

    char* const sdpDescription = resultString;
    env << *rtspClient << "Got a SDP description:\n" << sdpDescription << "\n";

    // Create a media session object from this SDP description:
    scs.session = MediaSession::createNew(env, sdpDescription);
    delete[] sdpDescription; // because we don't need it anymore
    if (scs.session == NULL) {
      env << *rtspClient << "Failed to create a MediaSession object from the SDP description: " << env.getResultMsg() << "\n";
      break;
    } else if (!scs.session->hasSubsessions()) {
      env << *rtspClient << "This session has no media subsessions (i.e., no \"m=\" lines)\n";
      break;
    }

    // Then, create and set up our data source objects for the session.  We do this by iterating over the session's 'subsessions',
    // calling "MediaSubsession::initiate()", and then sending a RTSP "SETUP" command, on each one.
    // (Each 'subsession' will have its own data source.)
    scs.iter = new MediaSubsessionIterator(*scs.session);
    setupNextSubsession(rtspClient);
    return;
  } while (0);

  // An unrecoverable error occurred with this stream.
  shutdownStream(rtspClient);
}

void setupNextSubsession(RTSPClient* rtspClient) {
  UsageEnvironment& env = rtspClient->envir(); // alias
  StreamClientState& scs = ((ourRTSPClient*)rtspClient)->scs; // alias
  
  scs.subsession = scs.iter->next();
  if (scs.subsession != NULL) {
    if (!scs.subsession->initiate()) {
      env << *rtspClient << "Failed to initiate the \"" << *scs.subsession << "\" subsession: " << env.getResultMsg() << "\n";
      setupNextSubsession(rtspClient); // give up on this subsession; go to the next one
    } else {
      env << *rtspClient << "Initiated the \"" << *scs.subsession << "\" subsession (";
      if (scs.subsession->rtcpIsMuxed()) {
	env << "client port " << scs.subsession->clientPortNum();
      } else {
	env << "client ports " << scs.subsession->clientPortNum() << "-" << scs.subsession->clientPortNum()+1;
      }
      env << ")\n";

      // Continue setting up this subsession, by sending a RTSP "SETUP" command:
      rtspClient->sendSetupCommand(*scs.subsession, continueAfterSETUP, False, REQUEST_STREAMING_OVER_TCP);
    }
    return;
  }

  // We've finished setting up all of the subsessions.  Now, send a RTSP "PLAY" command to start the streaming:
  if (scs.session->absStartTime() != NULL) {
    // Special case: The stream is indexed by 'absolute' time, so send an appropriate "PLAY" command:
    rtspClient->sendPlayCommand(*scs.session, continueAfterPLAY, scs.session->absStartTime(), scs.session->absEndTime());
  } else {
    scs.duration = scs.session->playEndTime() - scs.session->playStartTime();
    rtspClient->sendPlayCommand(*scs.session, continueAfterPLAY);
  }
}

void continueAfterSETUP(RTSPClient* rtspClient, int resultCode, char* resultString) {
  do {
    UsageEnvironment& env = rtspClient->envir(); // alias
    StreamClientState& scs = ((ourRTSPClient*)rtspClient)->scs; // alias

    if (resultCode != 0) {
      env << *rtspClient << "Failed to set up the \"" << *scs.subsession << "\" subsession: " << resultString << "\n";
      break;
    }

    env << *rtspClient << "Set up the \"" << *scs.subsession << "\" subsession (";
    if (scs.subsession->rtcpIsMuxed()) {
      env << "client port " << scs.subsession->clientPortNum();
    } else {
      env << "client ports " << scs.subsession->clientPortNum() << "-" << scs.subsession->clientPortNum()+1;
    }
    env << ")\n";

    // Having successfully setup the subsession, create a data sink for it, and call "startPlaying()" on it.
    // (This will prepare the data sink to receive data; the actual flow of data from the client won't start happening until later,
    // after we've sent a RTSP "PLAY" command.)

    scs.subsession->sink = DummySink::createNew(env, *scs.subsession, rtspClient->url());
      // perhaps use your own custom "MediaSink" subclass instead
    if (scs.subsession->sink == NULL) {
      env << *rtspClient << "Failed to create a data sink for the \"" << *scs.subsession
	  << "\" subsession: " << env.getResultMsg() << "\n";
      break;
    }

    env << *rtspClient << "Created a data sink for the \"" << *scs.subsession << "\" subsession\n";
    scs.subsession->miscPtr = rtspClient; // a hack to let subsession handler functions get the "RTSPClient" from the subsession 
    scs.subsession->sink->startPlaying(*(scs.subsession->readSource()),
				       subsessionAfterPlaying, scs.subsession);
    // Also set a handler to be called if a RTCP "BYE" arrives for this subsession:
    if (scs.subsession->rtcpInstance() != NULL) {
      scs.subsession->rtcpInstance()->setByeWithReasonHandler(subsessionByeHandler, scs.subsession);
    }
  } while (0);
  delete[] resultString;

  // Set up the next subsession, if any:
  setupNextSubsession(rtspClient);
}

void continueAfterPLAY(RTSPClient* rtspClient, int resultCode, char* resultString) {
  Boolean success = False;

  do {
    UsageEnvironment& env = rtspClient->envir(); // alias
    StreamClientState& scs = ((ourRTSPClient*)rtspClient)->scs; // alias

    if (resultCode != 0) {
      env << *rtspClient << "Failed to start playing session: " << resultString << "\n";
      break;
    }

    // Set a timer to be handled at the end of the stream's expected duration (if the stream does not already signal its end
    // using a RTCP "BYE").  This is optional.  If, instead, you want to keep the stream active - e.g., so you can later
    // 'seek' back within it and do another RTSP "PLAY" - then you can omit this code.
    // (Alternatively, if you don't want to receive the entire stream, you could set this timer for some shorter value.)
    if (scs.duration > 0) {
      unsigned const delaySlop = 2; // number of seconds extra to delay, after the stream's expected duration.  (This is optional.)
      scs.duration += delaySlop;
      unsigned uSecsToDelay = (unsigned)(scs.duration*1000000);
      scs.streamTimerTask = env.taskScheduler().scheduleDelayedTask(uSecsToDelay, (TaskFunc*)streamTimerHandler, rtspClient);
    }

    env << *rtspClient << "Started playing session";
    if (scs.duration > 0) {
      env << " (for up to " << scs.duration << " seconds)";
    }
    env << "...\n";

    success = True;
  } while (0);
  delete[] resultString;

  if (!success) {
    // An unrecoverable error occurred with this stream.
    shutdownStream(rtspClient);
  }
}

// Implementation of the other event handlers:
void subsessionAfterPlaying(void* clientData) {
  MediaSubsession* subsession = (MediaSubsession*)clientData;
  RTSPClient* rtspClient = (RTSPClient*)(subsession->miscPtr);

  // Begin by closing this subsession's stream:
  Medium::close(subsession->sink);
  subsession->sink = NULL;

  // Next, check whether *all* subsessions' streams have now been closed:
  MediaSession& session = subsession->parentSession();
  MediaSubsessionIterator iter(session);
  while ((subsession = iter.next()) != NULL) {
    if (subsession->sink != NULL) return; // this subsession is still active
  }

  // All subsessions' streams have now been closed, so shutdown the client:
  shutdownStream(rtspClient);
}

void subsessionByeHandler(void* clientData, char const* reason) {
  MediaSubsession* subsession = (MediaSubsession*)clientData;
  RTSPClient* rtspClient = (RTSPClient*)subsession->miscPtr;
  UsageEnvironment& env = rtspClient->envir(); // alias

  env << *rtspClient << "Received RTCP \"BYE\"";
  if (reason != NULL) {
    env << " (reason:\"" << reason << "\")";
    delete[] (char*)reason;
  }
  env << " on \"" << *subsession << "\" subsession\n";

  // Now act as if the subsession had closed:
  subsessionAfterPlaying(subsession);
}

void streamTimerHandler(void* clientData) {
  ourRTSPClient* rtspClient = (ourRTSPClient*)clientData;
  StreamClientState& scs = rtspClient->scs; // alias

  scs.streamTimerTask = NULL;

  // Shut down the stream:
  shutdownStream(rtspClient);
}

void shutdownStream(RTSPClient* rtspClient, int exitCode) {
  UsageEnvironment& env = rtspClient->envir(); // alias
  StreamClientState& scs = ((ourRTSPClient*)rtspClient)->scs; // alias

  // First, check whether any subsessions have still to be closed:
  if (scs.session != NULL) { 
    Boolean someSubsessionsWereActive = False;
    MediaSubsessionIterator iter(*scs.session);
    MediaSubsession* subsession;

    while ((subsession = iter.next()) != NULL) {
      if (subsession->sink != NULL) {
	Medium::close(subsession->sink);
	subsession->sink = NULL;

	if (subsession->rtcpInstance() != NULL) {
	  subsession->rtcpInstance()->setByeHandler(NULL, NULL); // in case the server sends a RTCP "BYE" while handling "TEARDOWN"
	}

	someSubsessionsWereActive = True;
      }
    }

    if (someSubsessionsWereActive) {
      // Send a RTSP "TEARDOWN" command, to tell the server to shutdown the stream.
      // Don't bother handling the response to the "TEARDOWN".
      rtspClient->sendTeardownCommand(*scs.session, NULL);
    }
  }

  env << *rtspClient << "Closing the stream.\n";
  Medium::close(rtspClient);
    // Note that this will also cause this stream's "StreamClientState" structure to get reclaimed.

  if (--rtspClientCount == 0) {
    // The final stream has ended, so exit the application now.
    // (Of course, if you're embedding this code into your own application, you might want to comment this out,
    // and replace it with "eventLoopWatchVariable = 1;", so that we leave the LIVE555 event loop, and continue running "main()".)
    exit(exitCode);
  }
}


// =================Implementation of "ourRTSPClient":==========================//
ourRTSPClient* ourRTSPClient::createNew(UsageEnvironment& env, char const* rtspURL,
					int verbosityLevel, char const* applicationName, portNumBits tunnelOverHTTPPortNum) {
  return new ourRTSPClient(env, rtspURL, verbosityLevel, applicationName, tunnelOverHTTPPortNum);
}

ourRTSPClient::ourRTSPClient(UsageEnvironment& env, char const* rtspURL,
			     int verbosityLevel, char const* applicationName, portNumBits tunnelOverHTTPPortNum)
  : RTSPClient(env,rtspURL, verbosityLevel, applicationName, tunnelOverHTTPPortNum, -1) {
}

ourRTSPClient::~ourRTSPClient() {
}


//================= Implementation of "StreamClientState":==========================//
StreamClientState::StreamClientState()
  : iter(NULL), session(NULL), subsession(NULL), streamTimerTask(NULL), duration(0.0) {
}

StreamClientState::~StreamClientState() {
  delete iter;
  if (session != NULL) {
    // We also need to delete "session", and unschedule "streamTimerTask" (if set)
    UsageEnvironment& env = session->envir(); // alias

    env.taskScheduler().unscheduleDelayedTask(streamTimerTask);
    Medium::close(session);
  }
}

// =================Implementation of "DummySink":===============================//
// Even though we're not going to be doing anything with the incoming data, we still need to receive it.
// Define the size of the buffer that we'll use:
DummySink* DummySink::createNew(UsageEnvironment& env, MediaSubsession& subsession, char const* streamId) {
  return new DummySink(env, subsession, streamId);
}

DummySink::DummySink(UsageEnvironment& env, MediaSubsession& subsession, char const* streamId)
  : MediaSink(env),
    fSubsession(subsession) {
  fStreamId = strDup(streamId);
  fReceiveBuffer = new u_int8_t[DUMMY_SINK_RECEIVE_BUFFER_SIZE];
  decBuffer = new u_int8_t[DUMMY_SINK_RECEIVE_BUFFER_SIZE];
  firstFrame=true;
}

DummySink::~DummySink() {
  delete[] fReceiveBuffer;
  delete[] fStreamId;
}

void DummySink::afterGettingFrame(void* clientData, unsigned frameSize, unsigned numTruncatedBytes,
				  struct timeval presentationTime, unsigned durationInMicroseconds) {
  DummySink* sink = (DummySink*)clientData;
  sink->afterGettingFrame(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
}

// If you don't want to see debugging output for each received frame, then comment out the following line:
void DummySink::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes,struct timeval presentationTime, unsigned /*durationInMicroseconds*/) {
  // We've just received a frame of data.  (Optionally) print out information about it:
#ifdef DEBUG_PRINT_EACH_RECEIVED_FRAME
	  if (fStreamId != NULL) 
		  envir() << "Stream \"" << fStreamId << "\"; ";
	  envir() << fSubsession.mediumName() << "/" << fSubsession.codecName() << ":\tReceived " << frameSize << " bytes";
	  if (numTruncatedBytes > 0) 
		  envir() << " (with " << numTruncatedBytes << " bytes truncated)";
	  char uSecsStr[6+1]; // used to output the 'microseconds' part of the presentation time
	  sprintf(uSecsStr, "%06u", (unsigned)presentationTime.tv_usec);
	  envir() << ".\tPresentation time: " << (int)presentationTime.tv_sec << "." << uSecsStr;
	  if (fSubsession.rtpSource() != NULL && !fSubsession.rtpSource()->hasBeenSynchronizedUsingRTCP())
	  {
		envir() << "!"; // mark the debugging output to indicate that this presentation time is not RTCP-synchronized
	  }
#ifdef DEBUG_PRINT_NPT
	 envir() << "\tNPT: " << fSubsession.getNormalPlayTime(presentationTime);
#endif
	 envir() << "\n";
#endif

	 unsigned char* RgbBuf;
	 unsigned int RgbSize = 0;
	 int RgbWidth = 0;
	 int RgbHeight = 0;
	memset(decBuffer, 0, DUMMY_SINK_RECEIVE_BUFFER_SIZE);
	int nTotalLen = 0;
	unsigned char start_code[4] = { 0x00, 0x00, 0x00, 0x01 };
	if (strcmp(fSubsession.mediumName(), "video") == 0 )
	{
			if (firstFrame)
			{
				/*for (unsigned j = 0; j < 3; ++j)
				{*/
					unsigned numSPropRecords;
					//if (j == 0)
					//if (fReceiveBuffer[0] == 0x65 || fReceiveBuffer[0] == 0x25 || fReceiveBuffer[0] == 0x68 || fReceiveBuffer[0] == 0x67)
					{
						SPropRecord* sPropRecords = parseSPropParameterSets(fSubsession.fmtp_spropparametersets(), numSPropRecords);
						for (unsigned i = 0; i < numSPropRecords; ++i)
						{
							memcpy(decBuffer + nTotalLen, start_code, 4);
							nTotalLen += 4;
							memcpy(decBuffer + nTotalLen, sPropRecords[i].sPropBytes, sPropRecords[i].sPropLength);
							nTotalLen += sPropRecords[i].sPropLength;
							/*printf("mvp------XXXXXXXXXXXXXXXXXXXXXXXXXXX---------------%d\n", sPropRecords[i].sPropLength);*/
						}
						delete[] sPropRecords;
					}
			}
			memcpy(decBuffer + nTotalLen, start_code, 4);
			nTotalLen += 4;
			memcpy(decBuffer + nTotalLen, fReceiveBuffer, frameSize);
			nTotalLen += frameSize;
			/*printf("mvp=========================================%d\n", nTotalLen);*/
			
 			{			
 				int   av_result = 0;
 				printf("Video decoding\n");
 				int nGetPic;
 			
 				pstructData->p_packet.data = decBuffer;
 				pstructData->p_packet.size = nTotalLen;
 				av_init_packet(&pstructData->p_packet);
 				av_result = avcodec_decode_video2(pstructData->p_codec_ctx, pstructData->p_frm_raw, &nGetPic, &pstructData->p_packet);
 
 				if (av_result < 0)
 				{
 					fprintf(stderr, "decode failed: decBuffer = 0x%x , input_framesize = %d\n", decBuffer, nTotalLen);
 					
 				}

 				if(nGetPic)
 				{
 					
 					firstFrame=false;
 					buf_size = avpicture_get_size(AV_PIX_FMT_YUV420P, pstructData->p_codec_ctx->width, pstructData->p_codec_ctx->height); 
 
 					// buffer将作为p_frm_yuv的视频数据缓冲区
 					buffer = (uint8_t *)av_malloc(buf_size);
 					avpicture_fill((AVPicture *)pstructData->p_frm_yuv, buffer, AV_PIX_FMT_YUV420P, pstructData->p_codec_ctx->width, pstructData->p_codec_ctx->height);
 
 					// A7. 初始化SWS context，用于后续图像转换
 					//     此处第6个参数使用的是FFmpeg中的像素格式，对比参考注释B4
 					//     FFmpeg中的像素格式AV_PIX_FMT_YUV420P对应SDL中的像素格式SDL_PIXELFORMAT_IYUV
 					//     如果解码后得到图像的不被SDL支持，不进行图像转换的话，SDL是无法正常显示图像的
 					//     如果解码后得到图像的能被SDL支持，则不必进行图像转换
 					//     这里为了编码简便，统一转换为SDL支持的格式AV_PIX_FMT_YUV420P==>SDL_PIXELFORMAT_IYUV
 					pstructData->sws_ctx = sws_getContext(pstructData->p_codec_ctx->width,    // src width
 						pstructData->p_codec_ctx->height,   // src height
 						pstructData->p_codec_ctx->pix_fmt,  // src format
 						pstructData->p_codec_ctx->width,    // dst width
 						pstructData->p_codec_ctx->height,   // dst height
 						AV_PIX_FMT_YUV420P, // dst format
 						SWS_BICUBIC,           // flags
 						NULL,                  // src filter
 						NULL,                  // dst filter
 						NULL                   // param
 						);              
 					sws_scale(pstructData->sws_ctx,  (const uint8_t *const *)pstructData->p_frm_raw->data,  pstructData->p_frm_raw->linesize, 0,pstructData->p_codec_ctx->height,pstructData->p_frm_yuv->data,pstructData->p_frm_yuv->linesize);
					SDL_WaitEvent(&mEvent);
					if(mEvent.type==REFRESH_EVENT)
					{
						// B5. 使用新的YUV像素数据更新SDL_Rect
						SDL_UpdateYUVTexture(pstructData->sdl_texture,&pstructData->sdl_rect,pstructData->p_frm_yuv->data[0], pstructData->p_frm_yuv->linesize[0],pstructData->p_frm_yuv->data[1],pstructData->p_frm_yuv->linesize[1],pstructData->p_frm_yuv->data[2],pstructData->p_frm_yuv->linesize[2]);

						// B6. 使用特定颜色清空当前渲染目标
						SDL_RenderClear(pstructData->sdl_renderer);
						// B7. 使用部分图像数据(texture)更新当前渲染目标
						SDL_RenderCopy(pstructData->sdl_renderer,pstructData->sdl_texture, NULL,&pstructData->sdl_rect);
						// B8. 执行渲染，更新屏幕显示
						SDL_RenderPresent(pstructData->sdl_renderer);  			
					}
					else if(mEvent.type==SDL_QUIT)
					{
						thread_exit=1;
						SDL_Quit();
						
					}
 					av_packet_unref(&pstructData->p_packet);	
 					av_free(buffer);
 				
 				}
 			}
	}
	continuePlaying();
}
Boolean DummySink::continuePlaying() {
  if (fSource == NULL) return False; // sanity check (should not happen)

  // Request the next frame of data from our input source.  "afterGettingFrame()" will get called later, when it arrives:
  fSource->getNextFrame(fReceiveBuffer, DUMMY_SINK_RECEIVE_BUFFER_SIZE,
                        afterGettingFrame, this,
                        onSourceClosure, this);
  return True;
}

int main(int argc, char** argv) {
  // Begin by setting up our usage environment:
  TaskScheduler* scheduler = BasicTaskScheduler::createNew();
  UsageEnvironment* env = BasicUsageEnvironment::createNew(*scheduler);

  // We need at least one "rtsp://" URL argument:
  if (argc < 2) {
    usage(*env, argv[0]);
    //return 1;
  }

  for (int i = 0; i <= argc-1; ++i) {
    openURL(*env, "test", "rtsp://192.168.27.1/out.ts");
  }
  pstructData = (structData*)malloc(sizeof(structData));
  FFmepgInit();
  SDLInit();

  SDL_Thread* sdlThread=SDL_CreateThread(SDLThread,"SDLThread",NULL);
  // All subsequent activity takes place within the event loop:
  env->taskScheduler().doEventLoop(&eventLoopWatchVariable);
    // This function call does not return, unless, at some point in time, "eventLoopWatchVariable" gets set to something non-zero.

  //SDL_Quit();
  //sws_freeContext(sws_ctx);

  //av_frame_free(&p_frm_yuv);
  //av_frame_free(&p_frm_raw);
  //avcodec_close(p_codec_ctx);

  system("pause");
  return 0;

  // If you choose to continue the application past this point (i.e., if you comment out the "return 0;" statement above),
  // and if you don't intend to do anything more with the "TaskScheduler" and "UsageEnvironment" objects,
  // then you can also reclaim the (small) memory used by these objects by uncommenting the following code:
  /*
    env->reclaim(); env = NULL;
    delete scheduler; scheduler = NULL;
  */
}