filecache.cpp

au1200 linux2.6.11 硬件解码mae驱动和maiplayer播放器源码

/* <LIC_AMD_STD>
 * Copyright (C) 2003-2005 Advanced Micro Devices, Inc.  All Rights Reserved.
 * 
 * Unless otherwise designated in writing, this software and any related 
 * documentation are the confidential proprietary information of AMD. 
 * THESE MATERIALS ARE PROVIDED "AS IS" WITHOUT ANY
 * UNLESS OTHERWISE NOTED IN WRITING, EXPRESS OR IMPLIED WARRANTY OF ANY 
 * KIND, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, 
 * NONINFRINGEMENT, TITLE, FITNESS FOR ANY PARTICULAR PURPOSE AND IN NO 
 * EVENT SHALL AMD OR ITS LICENSORS BE LIABLE FOR ANY DAMAGES WHATSOEVER. 
 * 
 * AMD does not assume any responsibility for any errors which may appear 
 * in the Materials nor any responsibility to support or update the
 * Materials.  AMD retains the right to modify the Materials at any time, 
 * without notice, and is not obligated to provide such modified 
 * Materials to you. AMD is not obligated to furnish, support, or make
 * any further information available to you.
 * </LIC_AMD_STD>  */
/* <CTL_AMD_STD>
 * </CTL_AMD_STD>  */
/* <DOC_AMD_STD>
 * </DOC_AMD_STD>  */
#pragma warning(disable: 4786)

#define CFUNC "C"
#ifndef OS_Linux
    #include <windows.h>
#endif
#include "filecache.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string>
#include <iostream>
#include <fstream>
#include <list>
#include <algorithm>

#include <signal.h>

#ifndef OS_Linux
CRITICAL_SECTION WrapCriticalSection;
#endif

static int init = 0;
#define CACHE_LENGTH 12
static CachedFILE filecache[CACHE_LENGTH];
static char* filenamecache[CACHE_LENGTH];
std::list<std::string> discard;

class DiscardPredicate {
private:
	std::string m_s;
public:
	DiscardPredicate(std::string s) : m_s(s)  {}
	int operator()(std::string other) {
		if (m_s.find(other) == 0) {
			return  1;
		}
		return 0;
	}
};

extern "C" void FileCacheAtExit()
{
	int i;

	std::cerr << "FileCache: Closing files\n";

	for (i=0; i < CACHE_LENGTH; i++) {
		if (filecache[i]) {
			fclose(filecache[i]);
			free(filenamecache[i]);
		}
		filecache[i] = 0;
		filenamecache[i] = 0;
	}
}

extern "C" void FileCacheAtSignal(int arg)
{
	std::cerr << "FileCache: Signal caught\n";

  FileCacheAtExit();

  exit(1);
}

void FileCacheInitialize()
{
	std::string pattern, yesno;
	std::ifstream cfg;
	for (int i=0; i < CACHE_LENGTH; i++) {
		filecache[i] = 0;
		filenamecache[i] = strdup("");
	}
	cfg.open("decoder.cfg");
	while (cfg) {
		cfg >> pattern >> yesno;
		if (yesno == "no") {
			discard.push_back(pattern);
		}
	}

	std::cerr << "FileCache: Registering atexit()\n";
	atexit(FileCacheAtExit);

	std::cerr << "FileCache: Registering SIGHUP, SIGINT\n";
  signal(SIGINT, &FileCacheAtSignal);
#ifdef SIGHUP
  signal(SIGHUP, &FileCacheAtSignal);
#endif

	init = 1;
}

extern "C" void CriticalSectionInit()
{
#ifndef OS_Linux
    if( !InitializeCriticalSectionAndSpinCount(&WrapCriticalSection,10) )
    {
        printf( "Filecache: Unable to initialize critical section.\n");
        exit(1);
    }
#endif
}

extern "C" void CriticalSectionExit()
{
#ifndef OS_Linux
    DeleteCriticalSection(&WrapCriticalSection);
#endif
}

// File caching
extern "C" CachedFILE FileCacheGet(const char *xFileName)
{
	char *pFileName = 0;
	int i;
	CachedFILE pFile = 0;

#ifndef OS_Linux
    EnterCriticalSection(&WrapCriticalSection);
#endif

	if (!init) FileCacheInitialize();

	std::list<std::string>::iterator it = std::find_if(discard.begin(), discard.end(), DiscardPredicate(xFileName));
	if (it != discard.end()) {
#ifndef OS_Linux
        LeaveCriticalSection(&WrapCriticalSection);
#endif
		return 0;
	}
	
	// Get a file from the cache
	for (i = 0; i < CACHE_LENGTH; i++) {
		if (strcmp(xFileName, filenamecache[i]) == 0) {
			pFileName = filenamecache[i];
			pFile = filecache[i];

			// Shift it to the end to make cache LRU
			for (; i < CACHE_LENGTH-1; i++) {
				filecache[i] = filecache[i+1];
				filenamecache[i] = filenamecache[i+1];
			}
			filecache[CACHE_LENGTH-1] = pFile;
			filenamecache[CACHE_LENGTH-1] = pFileName;
			break;
		}
	}
	if (!pFile) {
		// Rename file on Linux
		char buf[256];
#if defined(OS_Linux)
		sprintf(buf, "%s.gz", xFileName);
#else
		sprintf(buf, "%s", xFileName);
#endif
		pFile = fopen(buf, "a+");
		if (pFile) {
			// Insert in cache, discarding oldest entry.
			for (i = CACHE_LENGTH - 1; i > 0 && filecache[i]; i--) {
			}
			if (filecache[i]) fclose(filecache[i]);
			filecache[i] = pFile;
			free(filenamecache[i]);
			filenamecache[i] = strdup(xFileName);
		}
	}

#ifndef OS_Linux
    LeaveCriticalSection(&WrapCriticalSection);
#endif

	return pFile;
}

extern "C" void FileCacheDone(CachedFILE f)
{
}