C++ SDL_FreeYUVOverlay函数代码示例

SDL_Overlay *DirectFB_CreateYUVOverlay(_THIS, int width, int height, Uint32 format, SDL_Surface *display)
{
  SDL_Overlay *overlay;
  struct private_yuvhwdata *hwdata;

  /* Create the overlay structure */
  overlay = SDL_calloc (1, sizeof(SDL_Overlay));
  if (!overlay)
    {
      SDL_OutOfMemory();
      return NULL;
    }
	
  /* Fill in the basic members */
  overlay->format = format;
  overlay->w = width;
  overlay->h = height;

  /* Set up the YUV surface function structure */
  overlay->hwfuncs = &directfb_yuvfuncs;

  /* Create the pixel data and lookup tables */
  hwdata = SDL_calloc(1, sizeof(struct private_yuvhwdata));
  overlay->hwdata = hwdata;
  if (!hwdata)
    {
      SDL_OutOfMemory();
      SDL_FreeYUVOverlay (overlay);
      return NULL;
    }

  if (CreateYUVSurface (this, hwdata, width, height, format))
    {
      SDL_FreeYUVOverlay (overlay);
      return NULL;
    }

  overlay->hw_overlay = 1;

  /* Set up the plane pointers */
  overlay->pitches = hwdata->pitches;
  overlay->pixels = hwdata->planes;
  switch (format)
    {
    case SDL_YV12_OVERLAY:
    case SDL_IYUV_OVERLAY:
      overlay->planes = 3;
      break;
    default:
      overlay->planes = 1;
      break;
    }

  /* We're all done.. */
  return overlay;
}

void alloc_picture(void *userdata) {

    VideoState *is = (VideoState *)userdata;
    VideoPicture *vp;

    vp = &is->pictq[is->pictq_windex];

    if(vp->bmp) {
        // we already have one make another, bigger/smaller
        SDL_FreeYUVOverlay(vp->bmp);
    }

    // Allocate a place to put our YUV image on that screen
    vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,
                                   is->video_st->codec->height,
                                   SDL_YV12_OVERLAY,
                                   screen);
    vp->width = is->video_st->codec->width;
    vp->height = is->video_st->codec->height;

    SDL_LockMutex(is->pictq_mutex);
    vp->allocated = 1;
    SDL_CondSignal(is->pictq_cond);
    SDL_UnlockMutex(is->pictq_mutex);

}

static void ffmovie_cleanup(FFMovie *movie) {
    if(!movie)
        return;

    if(movie->audio_st) {
        packet_queue_abort(&movie->audioq);
        SDL_CloseAudio();
        packet_queue_end(&movie->audioq);
        avcodec_close(&movie->audio_st->codec);
        movie->audio_st = NULL;
    }

    if(movie->video_st) {
        avcodec_close(&movie->video_st->codec);
        movie->video_st = NULL;
    }

    if (movie->context) {
        av_close_input_file(movie->context);
        movie->context = NULL;
    }

    if(movie->dest_mutex) {
        SDL_DestroyMutex(movie->dest_mutex);
        movie->dest_mutex = NULL;
    }

    if (movie->dest_overlay) {
        SDL_FreeYUVOverlay(movie->dest_overlay);
        movie->dest_overlay = NULL;
    }

    Global_num_active--;
}

EC_VOID SDL_VideoRender::Uninit()
{
    SDL_FreeSurface(m_pScreen);
    SDL_FreeYUVOverlay(m_pOverlay);
    SDL_QuitSubSystem(SDL_INIT_VIDEO);
    SDL_Quit();
}

int do_video_options(int sel) {
    int old_stretch = display_cfg.stretch;
#ifdef RAINE_WIN32
    UINT32 old_driver = display_cfg.video_driver;
#endif
    // int oldx = display_cfg.screen_x,oldy = display_cfg.screen_y;
    video_options = new TVideo(_("Video options"), video_items);
    video_options->execute();
#ifdef RAINE_WIN32
    if (old_driver != display_cfg.video_driver) {
	if (sdl_overlay) {
	    SDL_FreeYUVOverlay(sdl_overlay);
	    sdl_overlay = NULL;
	}
	sdl_screen = NULL;
	SDL_QuitSubSystem(SDL_INIT_VIDEO);
	setup_video_driver();
	SDL_InitSubSystem(SDL_INIT_VIDEO);
	ScreenChange();
    }
#endif
    SetupScreenBitmap();
    if ((sdl_overlay != NULL || display_cfg.video_mode == 1) &&
	    display_cfg.video_mode != 2) {
	// explicitely clear scanlines when overlays are enabled
	display_cfg.scanlines = 0;
    }
    if (old_stretch != display_cfg.stretch && display_cfg.stretch == 3 &&
	    sdl_game_bitmap) {
	DestroyScreenBitmap(); // init hq2x/3x, switch gamebitmap to 16bpp
	// + recall InitLUTs by recreating game_bitmap when enabling hq2x/3x
    }
    return 0; // (oldx != display_cfg.screen_x || oldy != display_cfg.screen_y);
}

uint8_t sdlAccelRender::end( void)
{
        if(sdl_overlay)
        {
                SDL_FreeYUVOverlay(sdl_overlay);
        }
        if(sdl_display)
        {
        		SDL_UnlockSurface(sdl_display);
                SDL_FreeSurface(sdl_display);
        }
        if(sdl_running)
        {
                SDL_QuitSubSystem(SDL_INIT_VIDEO);

#ifdef __APPLE__
				destroyCocoaView();
#endif
        }
        if(decoded)
        {
		        delete [] decoded;
		        decoded=NULL;	
        }
        sdl_running=0;
        sdl_overlay=NULL;
        sdl_display=NULL;
        printf("[SDL] Video subsystem closed and destroyed\n");        
}

 ~SdlOverlayPort()
 {
     if (overlay_)
         SDL_FreeYUVOverlay(overlay_);
     if (sws_context_)
         sws_freeContext(sws_context_);
 }

SdlAbstract::~SdlAbstract () {
    if (mpBmp) {
        SDL_FreeYUVOverlay(mpBmp);
        mpBmp = NULL;
    }
    SDL_Quit ();
}

static void
overlay_dealloc (PyGameOverlay *self)
{
    if (SDL_WasInit (SDL_INIT_VIDEO) && self->cOverlay)
        SDL_FreeYUVOverlay (self->cOverlay);

    PyObject_Free ((PyObject*)self);
}

static OMX_ERRORTYPE
sdlivr_proc_stop_and_return (void *ap_obj)
{
  sdlivr_prc_t *p_prc = ap_obj;
  assert (NULL != p_prc);
  SDL_FreeYUVOverlay (p_prc->p_overlay);
  return OMX_ErrorNone;
}

ShowObject::~ShowObject(){
    SDL_FreeYUVOverlay(bmp);
    SDL_FreeSurface(screen);
    SDL_Quit();

    av_free(pFrame);
//    avcodec_close(pCodecCtx);
//    av_close_input_file(pFormatCtx);
}

SdlBlitter::~SdlBlitter() {
	if (overlay) {
		SDL_UnlockYUVOverlay(overlay);
		SDL_FreeYUVOverlay(overlay);
	}
	
	if (surface != screen)
		SDL_FreeSurface(surface);
}

/** Destructor. */
ImageDisplay::~ImageDisplay()
{
	delete _rect;

	SDL_FreeYUVOverlay(_overlay);
	SDL_FreeSurface(_surface);

	SDLKeeper::quit();
}

int main(int argc, char** argv)
{
    int ret = EXIT_SUCCESS;

    /* Initialize param struct to zero */
    memset(&P, 0, sizeof(P));

    if (!parse_input(argc, argv)) {
        return EXIT_FAILURE;
    }

    /* Initialize parameters corresponding to YUV-format */
    setup_param();

    if (!sdl_init()) {
        return EXIT_FAILURE;
    }

    if (!open_input()) {
        return EXIT_FAILURE;
    }

    if (!allocate_memory()) {
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* Lets do some basic consistency check on input */
    check_input();

    /* send event to display first frame */
    event.type = SDL_KEYDOWN;
    event.key.keysym.sym = SDLK_RIGHT;
    SDL_PushEvent(&event);

    /* while true */
    event_loop();

cleanup:
    destroy_message_queue();
    SDL_FreeYUVOverlay(my_overlay);
    free(P.raw);
    free(P.y_data);
    free(P.cb_data);
    free(P.cr_data);
    if (fd) {
        fclose(fd);
    }
    if (P.fd2) {
        fclose(P.fd2);
    }

    return ret;
}

void vid_close()
{
	if (overlay)
	{
		SDL_UnlockYUVOverlay(overlay);
		SDL_FreeYUVOverlay(overlay);
	}
	else SDL_UnlockSurface(screen);
	SDL_Quit();
	fb.enabled = 0;
}