From 6e8c389cbed0ba077882328258bf7e5ea8cc2f63 Mon Sep 17 00:00:00 2001 From: "erik.bystrom" Date: Mon, 14 Jul 2008 18:04:53 +0000 Subject: [PATCH] Basic functionallity --- hextool.py | 30 ++ pom.xml | 186 ++++++++++++ .../slackers/jss/mediastream/MediaStream.java | 20 ++ .../se/slackers/locality/dao/MetaTagDao.java | 48 ++++ .../java/se/slackers/locality/dao/TagDao.java | 45 +++ .../dao/hibernate/MetaTagDaoImpl.java | 64 +++++ .../locality/dao/hibernate/TagDaoImpl.java | 64 +++++ .../locality/data/CircularBuffer.java | 115 ++++++++ .../data/ExpandOnWriteCircularBuffer.java | 158 +++++++++++ .../data/FixedFrameSizeFrameStorage.java | 115 ++++++++ .../slackers/locality/data/FrameStorage.java | 54 ++++ .../locality/data/FrameStorageEntry.java | 50 ++++ .../locality/data/MetadataManager.java | 180 ++++++++++++ .../locality/data/TimeOffsetBuffer.java | 90 ++++++ .../CantCreateMediaReaderException.java | 25 ++ .../exception/DuplicateItemException.java | 25 ++ .../EncapsuledExceptionRuntimException.java | 20 ++ .../FrameHasNotBeenLoadedException.java | 30 ++ .../exception/FrameIsTooOldException.java | 30 ++ .../FrameStorageIsEmptyException.java | 26 ++ .../exception/IllegalRequestException.java | 30 ++ .../InvalidBufferPositionException.java | 25 ++ .../se/slackers/locality/media/Frame.java | 88 ++++++ .../queue/AbstractMediaQueueProcessor.java | 254 +++++++++++++++++ .../locality/media/queue/MediaQueue.java | 31 ++ .../locality/media/queue/MediaQueueImpl.java | 123 ++++++++ .../media/queue/MediaQueueProcessor.java | 31 ++ .../queue/MediaQueueProcessorListener.java | 14 + .../queue/PreloadDataMediaQueueProcessor.java | 67 +++++ .../media/reader/ByteStreamReader.java | 133 +++++++++ .../locality/media/reader/ByteUtils.java | 24 ++ .../locality/media/reader/MediaReader.java | 51 ++++ .../media/reader/MediaReaderFactory.java | 36 +++ .../media/reader/SilentMediaReader.java | 43 +++ .../media/reader/mp3/Mp3FrameHeader.java | 136 +++++++++ .../media/reader/mp3/Mp3MediaReader.java | 133 +++++++++ .../se/slackers/locality/model/Media.java | 20 ++ .../se/slackers/locality/model/MetaTag.java | 122 ++++++++ .../se/slackers/locality/model/Metadata.java | 52 ++++ .../slackers/locality/model/MetadataType.java | 8 + .../java/se/slackers/locality/model/Tag.java | 122 ++++++++ .../se/slackers/locality/net/HttpRequest.java | 32 +++ .../locality/shout/ClientListener.java | 14 + .../locality/shout/ShoutRunnable.java | 267 ++++++++++++++++++ .../slackers/locality/shout/ShoutServer.java | 90 ++++++ .../slackers/locality/shout/ShoutThread.java | 87 ++++++ .../locality/shout/ShoutThreadListener.java | 5 + .../locality/shout/ShoutThreadPool.java | 57 ++++ .../shout/manager/ShoutRequestManager.java | 24 ++ .../manager/ShoutRequestManagerImpl.java | 52 ++++ .../se/slackers/locality/util/OneShot.java | 16 ++ .../resources/application-context/data.xml | 89 ++++++ .../resources/application-context/main.xml | 13 + .../resources/application-context/shout.xml | 14 + src/main/resources/conf.properties | 5 + src/main/resources/log4j.properties | 16 ++ src/main/resources/schemas/locality.xsd | 43 +++ .../slackers/locality/dao/MetaTagDaoTest.java | 47 +++ .../se/slackers/locality/dao/TagDaoTest.java | 47 +++ .../se/slackers/locality/dao/TagTest.java | 45 +++ .../locality/data/CircularBufferTest.java | 100 +++++++ .../data/ExpandOnWriteCircularBufferTest.java | 45 +++ .../data/FixedFrameSizeFrameStorageTest.java | 48 ++++ .../locality/data/MetadataManagerTest.java | 21 ++ .../media/reader/mp3/Mp3MediaReaderTest.java | 41 +++ .../locality/net/HttpRequestTest.java | 19 ++ .../locality/shout/ShoutServerTest.java | 51 ++++ src/test/resources/silence.mp3 | Bin 0 -> 338 bytes src/test/resources/test.mp3 | Bin 0 -> 396241 bytes 69 files changed, 4206 insertions(+) create mode 100755 hextool.py create mode 100755 pom.xml create mode 100644 src/main/java/se/slackers/jss/mediastream/MediaStream.java create mode 100755 src/main/java/se/slackers/locality/dao/MetaTagDao.java create mode 100755 src/main/java/se/slackers/locality/dao/TagDao.java create mode 100755 src/main/java/se/slackers/locality/dao/hibernate/MetaTagDaoImpl.java create mode 100755 src/main/java/se/slackers/locality/dao/hibernate/TagDaoImpl.java create mode 100644 src/main/java/se/slackers/locality/data/CircularBuffer.java create mode 100644 src/main/java/se/slackers/locality/data/ExpandOnWriteCircularBuffer.java create mode 100644 src/main/java/se/slackers/locality/data/FixedFrameSizeFrameStorage.java create mode 100644 src/main/java/se/slackers/locality/data/FrameStorage.java create mode 100644 src/main/java/se/slackers/locality/data/FrameStorageEntry.java create mode 100644 src/main/java/se/slackers/locality/data/MetadataManager.java create mode 100644 src/main/java/se/slackers/locality/data/TimeOffsetBuffer.java create mode 100644 src/main/java/se/slackers/locality/exception/CantCreateMediaReaderException.java create mode 100644 src/main/java/se/slackers/locality/exception/DuplicateItemException.java create mode 100644 src/main/java/se/slackers/locality/exception/EncapsuledExceptionRuntimException.java create mode 100644 src/main/java/se/slackers/locality/exception/FrameHasNotBeenLoadedException.java create mode 100644 src/main/java/se/slackers/locality/exception/FrameIsTooOldException.java create mode 100644 src/main/java/se/slackers/locality/exception/FrameStorageIsEmptyException.java create mode 100644 src/main/java/se/slackers/locality/exception/IllegalRequestException.java create mode 100644 src/main/java/se/slackers/locality/exception/InvalidBufferPositionException.java create mode 100644 src/main/java/se/slackers/locality/media/Frame.java create mode 100644 src/main/java/se/slackers/locality/media/queue/AbstractMediaQueueProcessor.java create mode 100644 src/main/java/se/slackers/locality/media/queue/MediaQueue.java create mode 100644 src/main/java/se/slackers/locality/media/queue/MediaQueueImpl.java create mode 100644 src/main/java/se/slackers/locality/media/queue/MediaQueueProcessor.java create mode 100644 src/main/java/se/slackers/locality/media/queue/MediaQueueProcessorListener.java create mode 100644 src/main/java/se/slackers/locality/media/queue/PreloadDataMediaQueueProcessor.java create mode 100644 src/main/java/se/slackers/locality/media/reader/ByteStreamReader.java create mode 100644 src/main/java/se/slackers/locality/media/reader/ByteUtils.java create mode 100644 src/main/java/se/slackers/locality/media/reader/MediaReader.java create mode 100644 src/main/java/se/slackers/locality/media/reader/MediaReaderFactory.java create mode 100644 src/main/java/se/slackers/locality/media/reader/SilentMediaReader.java create mode 100644 src/main/java/se/slackers/locality/media/reader/mp3/Mp3FrameHeader.java create mode 100644 src/main/java/se/slackers/locality/media/reader/mp3/Mp3MediaReader.java create mode 100644 src/main/java/se/slackers/locality/model/Media.java create mode 100755 src/main/java/se/slackers/locality/model/MetaTag.java create mode 100644 src/main/java/se/slackers/locality/model/Metadata.java create mode 100644 src/main/java/se/slackers/locality/model/MetadataType.java create mode 100755 src/main/java/se/slackers/locality/model/Tag.java create mode 100644 src/main/java/se/slackers/locality/net/HttpRequest.java create mode 100644 src/main/java/se/slackers/locality/shout/ClientListener.java create mode 100644 src/main/java/se/slackers/locality/shout/ShoutRunnable.java create mode 100644 src/main/java/se/slackers/locality/shout/ShoutServer.java create mode 100644 src/main/java/se/slackers/locality/shout/ShoutThread.java create mode 100644 src/main/java/se/slackers/locality/shout/ShoutThreadListener.java create mode 100644 src/main/java/se/slackers/locality/shout/ShoutThreadPool.java create mode 100644 src/main/java/se/slackers/locality/shout/manager/ShoutRequestManager.java create mode 100644 src/main/java/se/slackers/locality/shout/manager/ShoutRequestManagerImpl.java create mode 100644 src/main/java/se/slackers/locality/util/OneShot.java create mode 100755 src/main/resources/application-context/data.xml create mode 100755 src/main/resources/application-context/main.xml create mode 100644 src/main/resources/application-context/shout.xml create mode 100755 src/main/resources/conf.properties create mode 100755 src/main/resources/log4j.properties create mode 100755 src/main/resources/schemas/locality.xsd create mode 100755 src/test/java/se/slackers/locality/dao/MetaTagDaoTest.java create mode 100755 src/test/java/se/slackers/locality/dao/TagDaoTest.java create mode 100755 src/test/java/se/slackers/locality/dao/TagTest.java create mode 100644 src/test/java/se/slackers/locality/data/CircularBufferTest.java create mode 100644 src/test/java/se/slackers/locality/data/ExpandOnWriteCircularBufferTest.java create mode 100644 src/test/java/se/slackers/locality/data/FixedFrameSizeFrameStorageTest.java create mode 100644 src/test/java/se/slackers/locality/data/MetadataManagerTest.java create mode 100644 src/test/java/se/slackers/locality/media/reader/mp3/Mp3MediaReaderTest.java create mode 100644 src/test/java/se/slackers/locality/net/HttpRequestTest.java create mode 100644 src/test/java/se/slackers/locality/shout/ShoutServerTest.java create mode 100644 src/test/resources/silence.mp3 create mode 100644 src/test/resources/test.mp3 diff --git a/hextool.py b/hextool.py new file mode 100755 index 0000000..78bbba0 --- /dev/null +++ b/hextool.py @@ -0,0 +1,30 @@ +#!/usr/bin/python +import sys + + +def toBinary(value): + s = "" + v = 128 + for i in range(8): + if value & v: + s += "1" + else: + s += "0" + v /= 2 + return s + +binstr = "" +for n in range(1, len(sys.argv)): + try: + value = int(sys.argv[n]) + except ValueError: + value = int(sys.argv[n], 16) + bin = toBinary(value) + print "%3d = 0x%02x = %sb" % (value, value, bin), + if (31 < value and value < 255): + print " = %c" % value + else: + print "" + binstr += bin + " " + +print binstr diff --git a/pom.xml b/pom.xml new file mode 100755 index 0000000..30b44a4 --- /dev/null +++ b/pom.xml @@ -0,0 +1,186 @@ + + + 4.0.0 + se.slackers.locality + locality + war + 1.0 + locality + locality + http://slackers.se/app/locality + + + + + eb + + Erik Byström + + erik.bystrom+lastfmsaver@gmail.com + + Developer + + slackers.se + +1 + + + + + + + + org.springframework + spring + 2.5 + + + + + com.h2database + h2 + 1.0.67 + + + + + org.hibernate + hibernate + 3.2.6.ga + + + org.hibernate + hibernate-commons-annotations + 3.3.0.ga + + + org.hibernate + hibernate-annotations + 3.3.0.ga + + + org.springframework + spring-hibernate3 + 2.0.8 + + + + + commons-logging + commons-logging + 1.1 + + + commons-digester + commons-digester + 1.8 + + + commons-dbcp + commons-dbcp + 1.2.2 + + + + + jdom + jdom + 1.0 + + + jaxen + jaxen + 1.1.1 + + + + + jgoodies + forms + 1.0.5 + + + org.swinglabs + swingx + 0.9 + + + + + commons-httpclient + commons-httpclient + 3.1 + + + + + junit + junit + 4.4 + + + org.springframework + spring-test + 2.5 + + + + + + + + org.apache.maven.plugins + maven-eclipse-plugin + + true + true + + + + org.apache.maven.plugins + maven-compiler-plugin + + 1.5 + 1.5 + + + + + + + + + org.apache.maven.plugins + maven-surefire-report-plugin + + + + org.apache.maven.plugins + maven-jxr-plugin + + + + org.apache.maven.plugins + maven-javadoc-plugin + + + + http://java.sun.com/j2ee/1.4/docs/api + + + http://java.sun.com/j2se/1.5.0/docs/api + + + + + + + org.apache.maven.plugins + + maven-project-info-reports-plugin + + + + + \ No newline at end of file diff --git a/src/main/java/se/slackers/jss/mediastream/MediaStream.java b/src/main/java/se/slackers/jss/mediastream/MediaStream.java new file mode 100644 index 0000000..c1744c2 --- /dev/null +++ b/src/main/java/se/slackers/jss/mediastream/MediaStream.java @@ -0,0 +1,20 @@ +package se.slackers.jss.mediastream; + +import java.io.InputStream; + +/** + * BaseClass for classes that stream audio data. + * @author bysse + * + */ +abstract public class MediaStream { + private InputStream inputStream; + + public InputStream getInputStream() { + return inputStream; + } + + public void setInputStream(InputStream inputStream) { + this.inputStream = inputStream; + } +} diff --git a/src/main/java/se/slackers/locality/dao/MetaTagDao.java b/src/main/java/se/slackers/locality/dao/MetaTagDao.java new file mode 100755 index 0000000..f2646ac --- /dev/null +++ b/src/main/java/se/slackers/locality/dao/MetaTagDao.java @@ -0,0 +1,48 @@ +package se.slackers.locality.dao; + +import java.util.List; + +import se.slackers.locality.model.MetaTag; + + +public interface MetaTagDao { + + + /** + * Removes the metatag from the database and deletes all references to it. + * @param tag + */ + public void delete(MetaTag tag); + + /** + * Find a metatag by the metatag id. If no metatag was found a DataRetrievalFailureException is thrown. + * + * @param id + * @return + */ + public MetaTag get(Long id); + + /** + * Find a metatag by the name of the metatag. If no metatag was found a DataRetrievalFailureException is thrown. + * + * @param name + * @return + */ + public MetaTag get(String name); + + /** + * Searches for metatags that have similar names to the given string. Before the search the name is converted to + * lower case. + * + * @param name + * @return + */ + public List getLike(String name); + + /** + * Saves or updates the metatag. + * + * @param metatag + */ + public void save(MetaTag metatag); +} diff --git a/src/main/java/se/slackers/locality/dao/TagDao.java b/src/main/java/se/slackers/locality/dao/TagDao.java new file mode 100755 index 0000000..4d4cd71 --- /dev/null +++ b/src/main/java/se/slackers/locality/dao/TagDao.java @@ -0,0 +1,45 @@ +package se.slackers.locality.dao; + +import java.util.List; + +import se.slackers.locality.model.Tag; + +public interface TagDao { + /** + * Removes the tag from the database and deletes all references to it. + * @param tag + */ + public void delete(Tag tag); + + /** + * Find a tag by the tag id. If no tag was found a DataRetrievalFailureException is thrown. + * + * @param id + * @return + */ + public Tag get(Long id); + + /** + * Find a tag by the name of the tag. If no tag was found a DataRetrievalFailureException is thrown. + * + * @param name + * @return + */ + public Tag get(String name); + + /** + * Searches for tags that have similar names to the given string. Before the search the name is converted to + * lower case. + * + * @param name + * @return + */ + public List getLike(String name); + + /** + * Saves or updates the tag. + * + * @param tag + */ + public void save(Tag tag); +} diff --git a/src/main/java/se/slackers/locality/dao/hibernate/MetaTagDaoImpl.java b/src/main/java/se/slackers/locality/dao/hibernate/MetaTagDaoImpl.java new file mode 100755 index 0000000..7ce47cc --- /dev/null +++ b/src/main/java/se/slackers/locality/dao/hibernate/MetaTagDaoImpl.java @@ -0,0 +1,64 @@ +package se.slackers.locality.dao.hibernate; + +import java.util.List; + +import org.springframework.dao.DataRetrievalFailureException; +import org.springframework.orm.hibernate3.support.HibernateDaoSupport; + +import se.slackers.locality.dao.MetaTagDao; +import se.slackers.locality.model.MetaTag; + +public class MetaTagDaoImpl extends HibernateDaoSupport implements MetaTagDao { + + /** + * {@inheritDoc} + */ + public void delete(MetaTag tag) { + getHibernateTemplate().delete(tag); + } + + /** + * {@inheritDoc} + */ + @SuppressWarnings("unchecked") + public MetaTag get(Long id) { + List result = (List)getHibernateTemplate().find("from MetaTag tag fetch all properties where tag.id=?", id); + + if (result.isEmpty()) + throw new DataRetrievalFailureException("No metatag with id "+id+" could be found"); + + assert result.size() == 1 : "More than one metatag found with id "+id; + + return result.get(0); + } + + /** + * {@inheritDoc} + */ + @SuppressWarnings("unchecked") + public MetaTag get(String name) { + List result = (List)getHibernateTemplate().find("from MetaTag tag fetch all properties where tag.name=?", name); + + if (result.isEmpty()) + throw new DataRetrievalFailureException("No metatag with name "+name+" could be found"); + + assert result.size() == 1 : "More than one metatag found with name "+name; + + return result.get(0); + } + + /** + * {@inheritDoc} + */ + @SuppressWarnings("unchecked") + public List getLike(String name) { + return (List)getHibernateTemplate().find("from MetaTag tag fetch all properties where lower(tag.name) like ? order by tag.name", name.toLowerCase()); + } + + /** + * {@inheritDoc} + */ + public void save(MetaTag tag) { + getHibernateTemplate().saveOrUpdate(tag); + } +} diff --git a/src/main/java/se/slackers/locality/dao/hibernate/TagDaoImpl.java b/src/main/java/se/slackers/locality/dao/hibernate/TagDaoImpl.java new file mode 100755 index 0000000..d459e87 --- /dev/null +++ b/src/main/java/se/slackers/locality/dao/hibernate/TagDaoImpl.java @@ -0,0 +1,64 @@ +package se.slackers.locality.dao.hibernate; + +import java.util.List; + +import org.springframework.dao.DataRetrievalFailureException; +import org.springframework.orm.hibernate3.support.HibernateDaoSupport; + +import se.slackers.locality.dao.TagDao; +import se.slackers.locality.model.Tag; + +public class TagDaoImpl extends HibernateDaoSupport implements TagDao { + + /** + * {@inheritDoc} + */ + public void delete(Tag tag) { + getHibernateTemplate().delete(tag); + } + + /** + * {@inheritDoc} + */ + @SuppressWarnings("unchecked") + public Tag get(Long id) { + List result = (List)getHibernateTemplate().find("from Tag tag fetch all properties where tag.id=?", id); + + if (result.isEmpty()) + throw new DataRetrievalFailureException("No tag with id "+id+" could be found"); + + assert result.size() == 1 : "More than one tag found with id "+id; + + return result.get(0); + } + + /** + * {@inheritDoc} + */ + @SuppressWarnings("unchecked") + public Tag get(String name) { + List result = (List)getHibernateTemplate().find("from Tag tag fetch all properties where tag.name=?", name); + + if (result.isEmpty()) + throw new DataRetrievalFailureException("No tag with name "+name+" could be found"); + + assert result.size() == 1 : "More than one tag found with name "+name; + + return result.get(0); + } + + /** + * {@inheritDoc} + */ + @SuppressWarnings("unchecked") + public List getLike(String name) { + return (List)getHibernateTemplate().find("from Tag tag fetch all properties where lower(tag.name) like ? order by tag.name", name.toLowerCase()); + } + + /** + * {@inheritDoc} + */ + public void save(Tag tag) { + getHibernateTemplate().saveOrUpdate(tag); + } +} diff --git a/src/main/java/se/slackers/locality/data/CircularBuffer.java b/src/main/java/se/slackers/locality/data/CircularBuffer.java new file mode 100644 index 0000000..5394e93 --- /dev/null +++ b/src/main/java/se/slackers/locality/data/CircularBuffer.java @@ -0,0 +1,115 @@ +package se.slackers.locality.data; + +import java.nio.ByteBuffer; + +public class CircularBuffer { + private ByteBuffer buffer; + private int readIndex = 0; + private int writeIndex = 0; + + public CircularBuffer(int bufferSize) { + buffer = ByteBuffer.allocateDirect(bufferSize); + } + + public void reset() { + readIndex = 0; + writeIndex = 0; + } + + public int read(byte [] dest, int offset, int length) { + assert length < buffer.capacity() : "The requested read is bigger than the buffer"; + + if (writeIndex == readIndex) { + return 0; + } + + buffer.position(readIndex); + if (writeIndex < readIndex) { + int remainder = buffer.remaining(); + if (remainder < length) { + buffer.get(dest, offset, remainder); + + offset += remainder; + length -= remainder; + + readIndex = 0; + buffer.position(readIndex); + + int space = writeIndex-readIndex; + if (space <= length) { + length = space; + } + + buffer.get(dest, offset, length); + readIndex += length; + + return remainder + length; + } else { + buffer.get(dest, offset, remainder); + readIndex += remainder; + return remainder; + } + } else { + int space = writeIndex - readIndex; + if (space <= length) { + length = space; + } + + buffer.get(dest, offset, length); + readIndex += length; + return length; + } + } + + public boolean write(byte [] source, int offset, int length) { + assert length < buffer.capacity() : "The requested write is bigger than the buffer"; + + buffer.position(writeIndex); + + + if ( (readIndex <= writeIndex && writeIndex + length < buffer.capacity()) || + (writeIndex < readIndex && length < readIndex-writeIndex)) { + // source fits in the remainder of the buffer + buffer.put(source, offset, length); + writeIndex += length; + return true; + } else { + // the source don't fit in the buffer without wrapping + int remainder = buffer.remaining(); + + if (readIndex < writeIndex && length > readIndex + remainder) { + return false; + } + if (writeIndex < readIndex && length > readIndex-writeIndex) { + return false; + } + + + buffer.put(source, offset, remainder); + + offset += remainder; + length -= remainder; + + writeIndex = 0; + buffer.position(writeIndex); + + assert length < readIndex : "There is not enough room for this write operation"; + buffer.put(source, offset, length); + writeIndex += length; + + return true; + } + } + + public boolean isEmpty() { + return writeIndex == readIndex; + } + + public boolean isFull() { + if (writeIndex+1 <= buffer.capacity() && writeIndex+1 == readIndex) + return true; + if (writeIndex == buffer.capacity()-1 && readIndex == 0) + return true; + return false; + } +} diff --git a/src/main/java/se/slackers/locality/data/ExpandOnWriteCircularBuffer.java b/src/main/java/se/slackers/locality/data/ExpandOnWriteCircularBuffer.java new file mode 100644 index 0000000..ab3df97 --- /dev/null +++ b/src/main/java/se/slackers/locality/data/ExpandOnWriteCircularBuffer.java @@ -0,0 +1,158 @@ +package se.slackers.locality.data; + +import java.nio.ByteBuffer; + +import se.slackers.locality.exception.InvalidBufferPositionException; + +public class ExpandOnWriteCircularBuffer { + private ByteBuffer buffer; + private int readOffset = 0; + private int readIndex = 0; + private int writeIndex = 0; + + public ExpandOnWriteCircularBuffer(int bufferSize) { + buffer = ByteBuffer.allocateDirect(bufferSize); + } + + public void reset() { + readOffset = 0; + readIndex = 0; + writeIndex = 0; + } + + public synchronized int read(int position, byte [] dest, int destOffset, int destLength) { + assert destLength < buffer.capacity() : "The requested read is bigger than the buffer"; + + // make sure the position is larger than the smallest buffer position + if (position < readOffset) { + throw new InvalidBufferPositionException("Read position "+position+" is smaller than ["+readOffset+"]"); + } + // make sure the position is smaller then the smallest buffer position + int offset = position - readOffset; + if (offset > getBytesInBuffer()) { + throw new InvalidBufferPositionException("Read position "+position+" is larger then ["+(readOffset+getBytesInBuffer())+"]"); + } + + // check if the buffer is empty + if (writeIndex == readIndex) { + return 0; + } + + buffer.position(offset); + if (writeIndex < readIndex) { + int remainder = buffer.remaining(); + if (remainder < destLength) { + buffer.get(dest, destOffset, remainder); + + destOffset += remainder; + destLength -= remainder; + + buffer.position(0); + + int space = writeIndex-0; + if (space <= destLength) { + destLength = space; + } + + buffer.get(dest, destOffset, destLength); + + return remainder + destLength; + } else { + buffer.get(dest, destOffset, remainder); + return remainder; + } + } else { + int space = writeIndex - offset; + if (space <= destLength) { + destLength = space; + } + + buffer.get(dest, destOffset, destLength); + return destLength; + } + } + + public synchronized boolean write(byte [] source, int offset, int length) { + assert length < buffer.capacity() : "The requested write is bigger than the buffer"; + + buffer.position(writeIndex); + + if (length < buffer.capacity()-getBytesInBuffer()) { + // the write fits in the buffer without changing the readIndex + if (writeIndex <= readIndex) { + + assert (readIndex-writeIndex) == (buffer.capacity()-getBytesInBuffer()) : "Buffer size is invalid"; + + buffer.put(source, offset, length); + writeIndex += length; + return true; + } else { + int remainder = buffer.remaining(); + if (length < remainder) { + // the write fits in the remaining buffer + buffer.put(source, offset, length); + writeIndex += length; + return true; + } else { + // the write needs to be wrapped + buffer.put(source, offset, remainder); + buffer.position(0); + buffer.put(source, offset+remainder, length-remainder); + writeIndex = length-remainder; + return true; + } + } + } else { + // readIndex needs to be changed after the write + int remainder = buffer.remaining(); + if (length < remainder) { + // the write fits in the remaining buffer + buffer.put(source, offset, length); + writeIndex += length; + } else { + // the write needs to be wrapped + buffer.put(source, offset, remainder); + buffer.position(0); + buffer.put(source, offset+remainder, length-remainder); + writeIndex = length-remainder; + } + + int oldRead = readIndex; + readIndex = writeIndex + 1; + if (readIndex >= buffer.capacity()) { + readIndex -= buffer.capacity(); + } + + // increase the offset index + if (readIndex < oldRead) { + readOffset += buffer.capacity()-oldRead + readIndex; + } else { + readOffset += readIndex-oldRead; + } + return true; + } + } + + public int getReadOffset() { + return readOffset; + } + + public boolean isEmpty() { + return writeIndex == readIndex; + } + + public boolean isFull() { + if (writeIndex+1 <= buffer.capacity() && writeIndex+1 == readIndex) + return true; + if (writeIndex == buffer.capacity()-1 && readIndex == 0) + return true; + return false; + } + + private int getBytesInBuffer() { + if (writeIndex < readIndex) { + return (buffer.capacity()-readIndex) + writeIndex; + } + return writeIndex-readIndex; + } +} diff --git a/src/main/java/se/slackers/locality/data/FixedFrameSizeFrameStorage.java b/src/main/java/se/slackers/locality/data/FixedFrameSizeFrameStorage.java new file mode 100644 index 0000000..2464e70 --- /dev/null +++ b/src/main/java/se/slackers/locality/data/FixedFrameSizeFrameStorage.java @@ -0,0 +1,115 @@ +package se.slackers.locality.data; + +import java.util.Iterator; +import java.util.LinkedList; + +import org.apache.log4j.Logger; + +import se.slackers.locality.exception.FrameHasNotBeenLoadedException; +import se.slackers.locality.exception.FrameIsTooOldException; +import se.slackers.locality.exception.FrameStorageIsEmptyException; + +/** + * Threadsafe. + * + * @author bysse + * + */ +public class FixedFrameSizeFrameStorage implements FrameStorage { + private static final Logger log = Logger.getLogger(FixedFrameSizeFrameStorage.class); + + private LinkedList frames = new LinkedList(); + private long frameLength = 26; // MP3 frame length + + /** + * {@inheritDoc} + */ + public synchronized FrameStorageEntry find(long time) { + if (frames.isEmpty()) { + throw new FrameStorageIsEmptyException(); + } + + long firstFrameTime = frames.getFirst().getStartTime(); + long lastFrameTime = frames.getLast().getStopTime(); + + // make sure the frame is within the represented interval + if (lastFrameTime <= time) { + //log.debug("Request: "+time+", LastFrame: "+lastFrameTime+", Diff: "+(time-lastFrameTime)); + throw new FrameHasNotBeenLoadedException(); + } + + if (time < firstFrameTime) { + throw new FrameIsTooOldException(); + } + + int index = (int) ((time - firstFrameTime) / frameLength); + + return frames.get(index); + } + + /** + * {@inheritDoc} + */ + public synchronized void add(FrameStorageEntry entry) { + frames.add(entry); + } + + /** + * {@inheritDoc} + */ + public synchronized void purgeUntil(long time) { + //log.debug("Purging framestorage until "+time); + + Iterator iterator = frames.iterator(); + + while (iterator.hasNext()) { + if (iterator.next().getStopTime() <= time) { + iterator.remove(); + } else { + break; + } + } + } + + /** + * {@inheritDoc} + */ + public synchronized long getFirstFrameTime() { + if (frames.isEmpty()) { + throw new FrameStorageIsEmptyException(); + } + + return frames.getFirst().getStartTime(); + } + + /** + * {@inheritDoc} + */ + public synchronized long getLastFrameTime() { + if (frames.isEmpty()) { + throw new FrameStorageIsEmptyException(); + } + + return frames.getLast().getStopTime(); + } + + /** + * Returns the frame length that is used by the instance. + * @return The frame length in milliseconds + */ + public long getFrameLength() { + return frameLength; + } + + public void setFrameLength(long frameLength) { + this.frameLength = frameLength; + } + + /** + * {@inheritDoc} + */ + public synchronized void clear() { + log.debug("Clearing frame storage"); + frames.clear(); + } +} diff --git a/src/main/java/se/slackers/locality/data/FrameStorage.java b/src/main/java/se/slackers/locality/data/FrameStorage.java new file mode 100644 index 0000000..905763e --- /dev/null +++ b/src/main/java/se/slackers/locality/data/FrameStorage.java @@ -0,0 +1,54 @@ +package se.slackers.locality.data; + +import se.slackers.locality.exception.FrameHasNotBeenLoadedException; + +public interface FrameStorage { + + /** + * Adds a frame to the FrameStorage. This method only adds the frame to the + * end of the storage. So adding out-of-order frames will cause error in + * playback. + * + * @param entry + */ + public void add(FrameStorageEntry entry); + + /** + * Returns the frame that overlaps the given time. If the FrameStorage is + * empty {@link FrameStorageIsEmptyException} is be thrown. If no frame + * could be found for the specified time {@link FrameHasNotBeenLoadedException} or + * {@link FrameIsTooOldException} is thrown. + * + * @param time + * @return A FrameStorageEntry that overlapped the given time. + */ + public FrameStorageEntry find(long time); + + /** + * Removes all frames that doesn't overlap the given time. + * + * @param time + */ + public void purgeUntil(long time); + + /** + * Clears the frame storage. + */ + public void clear(); + + /** + * Returns the start time of the first frame. If the storage is empty + * {@link FrameStorageIsEmptyException} will be thrown. + * + * @return Start time of first frame. + */ + public long getFirstFrameTime(); + + /** + * Returns the end time of the last frame. If the storage is empty + * {@link FrameStorageIsEmptyException} will be thrown. + * + * @return End time of the last frame in storage. + */ + public long getLastFrameTime(); +} diff --git a/src/main/java/se/slackers/locality/data/FrameStorageEntry.java b/src/main/java/se/slackers/locality/data/FrameStorageEntry.java new file mode 100644 index 0000000..6abd987 --- /dev/null +++ b/src/main/java/se/slackers/locality/data/FrameStorageEntry.java @@ -0,0 +1,50 @@ +package se.slackers.locality.data; + +import se.slackers.locality.media.Frame; + +/** + * Immutable class that wraps a frame with start and stop times. + * @author bysse + * + */ +public class FrameStorageEntry implements Comparable { + private long startTime; + private long stopTime; + private Frame frame; + + public FrameStorageEntry(long time, Frame frame) { + this.startTime = time; + this.stopTime = time + frame.getLength(); + this.frame = frame; + } + + public long getStartTime() { + return startTime; + } + + public long getStopTime() { + return stopTime; + } + + public Frame getFrame() { + return frame; + } + + /** + * This implementation considers overlapping intervals to be equal. + */ + public int compareTo(FrameStorageEntry o) { + if (stopTime < o.startTime) + return -1; + + if (startTime >= o.stopTime) + return 1; + + return 0; + } + + @Override + public String toString() { + return "Spans from "+getStartTime()+" to "+getStopTime() +" ("+getFrame()+")"; + } +} diff --git a/src/main/java/se/slackers/locality/data/MetadataManager.java b/src/main/java/se/slackers/locality/data/MetadataManager.java new file mode 100644 index 0000000..c71a12a --- /dev/null +++ b/src/main/java/se/slackers/locality/data/MetadataManager.java @@ -0,0 +1,180 @@ +package se.slackers.locality.data; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.apache.log4j.Logger; +import org.springframework.util.StringUtils; + +import se.slackers.locality.media.queue.MediaQueue; +import se.slackers.locality.media.queue.MediaQueueProcessorListener; +import se.slackers.locality.model.Media; +import se.slackers.locality.model.Metadata; +import se.slackers.locality.model.MetadataType; + +/** + * Controls when a full metadata chunk should be rendered and in which format. + * @author bysse + * + */ +public class MetadataManager implements MediaQueueProcessorListener { + private static Logger log = Logger.getLogger(MetadataManager.class); + private final static int maximumMetadataLength = 4095; + + private final static Pattern field = Pattern.compile("(\\$\\{([^\\}\\$]+)\\})|(\\$([^\\s\\?\\$]+))"); + private final static Pattern condition = Pattern.compile("\\?\\(([^,]+),([^\\)]+)\\)"); + + private String format = "$artist ?(album,- )$album ?(title,- )$title"; + private String cachedMetadataString = ""; + private Metadata currentMetadata = null; + + private long sendMetadataInterval = 15000; + private long lastMetadataChunk = 0; + + /** + * Default constructor. Sets the metadata to "Nothing playing" + */ + public MetadataManager() { + setMetadata(Metadata.create("Nothing playing", null, null)); + } + + /** + * Formats and returns a byte array containing metadata information from the MediaQueue. + * @param mediaQueue + * @return + */ + public byte [] getMetaData(MediaQueue mediaQueue) { + long time = System.currentTimeMillis(); + + if (time - lastMetadataChunk > sendMetadataInterval) { + log.debug("Send full metadata chunk ("+cachedMetadataString+")"); + + //.. return a full metadata string + lastMetadataChunk = time; + + // restrict the length of the metadata + if (cachedMetadataString.length() > maximumMetadataLength ) { + cachedMetadataString = cachedMetadataString.substring(0, maximumMetadataLength); + } + + int metadataLenth = cachedMetadataString.length(); + int encodedLength = ((int)Math.ceil(metadataLenth / 16.0)); + int blockLength = 16 * encodedLength; + + byte [] result = new byte[blockLength+1]; + result[0] = (byte)encodedLength; + + System.arraycopy(cachedMetadataString.getBytes(), 0, result, 1, metadataLenth); + + // add padding to the block + for (int i=metadataLenth+1;i time) { + if (index > 0) { + return this.offset[index-1]; + } else { + return this.offset[bufferSize-1]; + } + } + } + + return -1; + } + + public long getMinTime() { + return this.time[readIndex]; + } + + public long getMaxTime() { + if (writeIndex > 0) { + return this.offset[writeIndex-1]; + } else { + return this.offset[bufferSize-1]; + } + } + + /** + * Returns the number of elements in the buffer. + * @return + */ + private int getBufferContentSize() { + if (readIndex <= writeIndex) { + return writeIndex-readIndex; + } + + return bufferSize-readIndex + writeIndex; + } + + /** + * Increases the write index by one. This method also adjusts the + * readIndex. + */ + private void increaseWriteIndex() { + writeIndex++; + + if (writeIndex == readIndex) { + readIndex++; + } + + if (writeIndex >= bufferSize) { + writeIndex -= bufferSize; + } + + if (readIndex >= bufferSize) { + readIndex -= bufferSize; + } + } +} diff --git a/src/main/java/se/slackers/locality/exception/CantCreateMediaReaderException.java b/src/main/java/se/slackers/locality/exception/CantCreateMediaReaderException.java new file mode 100644 index 0000000..08989a4 --- /dev/null +++ b/src/main/java/se/slackers/locality/exception/CantCreateMediaReaderException.java @@ -0,0 +1,25 @@ +package se.slackers.locality.exception; + +public class CantCreateMediaReaderException extends RuntimeException { + + public CantCreateMediaReaderException() { + super(); + // TODO Auto-generated constructor stub + } + + public CantCreateMediaReaderException(String arg0, Throwable arg1) { + super(arg0, arg1); + // TODO Auto-generated constructor stub + } + + public CantCreateMediaReaderException(String arg0) { + super(arg0); + // TODO Auto-generated constructor stub + } + + public CantCreateMediaReaderException(Throwable arg0) { + super(arg0); + // TODO Auto-generated constructor stub + } + +} diff --git a/src/main/java/se/slackers/locality/exception/DuplicateItemException.java b/src/main/java/se/slackers/locality/exception/DuplicateItemException.java new file mode 100644 index 0000000..8a97723 --- /dev/null +++ b/src/main/java/se/slackers/locality/exception/DuplicateItemException.java @@ -0,0 +1,25 @@ +package se.slackers.locality.exception; + +/** + * Exception class for duplicate item errors in search tree insertions. + * + * @author Mark Allen Weiss + */ +public class DuplicateItemException extends RuntimeException { + /** + * Construct this exception object. + */ + public DuplicateItemException() { + super(); + } + + /** + * Construct this exception object. + * + * @param message + * the error message. + */ + public DuplicateItemException(String message) { + super(message); + } +} diff --git a/src/main/java/se/slackers/locality/exception/EncapsuledExceptionRuntimException.java b/src/main/java/se/slackers/locality/exception/EncapsuledExceptionRuntimException.java new file mode 100644 index 0000000..945e06e --- /dev/null +++ b/src/main/java/se/slackers/locality/exception/EncapsuledExceptionRuntimException.java @@ -0,0 +1,20 @@ +package se.slackers.locality.exception; + +/** + * Encapsules an exception in a RuntimeException. + * @author bysse + * + */ +public class EncapsuledExceptionRuntimException extends RuntimeException { + private static final long serialVersionUID = 794221656425404393L; + + private Exception exception = null; + + public EncapsuledExceptionRuntimException(Exception exception) { + this.exception = exception; + } + + public void rethrow() throws Exception { + throw this.exception; + } +} diff --git a/src/main/java/se/slackers/locality/exception/FrameHasNotBeenLoadedException.java b/src/main/java/se/slackers/locality/exception/FrameHasNotBeenLoadedException.java new file mode 100644 index 0000000..1a2f4a7 --- /dev/null +++ b/src/main/java/se/slackers/locality/exception/FrameHasNotBeenLoadedException.java @@ -0,0 +1,30 @@ +package se.slackers.locality.exception; + +public class FrameHasNotBeenLoadedException extends RuntimeException { + + /** + * + */ + private static final long serialVersionUID = 8666136563915734945L; + + public FrameHasNotBeenLoadedException() { + super(); + // TODO Auto-generated constructor stub + } + + public FrameHasNotBeenLoadedException(String arg0, Throwable arg1) { + super(arg0, arg1); + // TODO Auto-generated constructor stub + } + + public FrameHasNotBeenLoadedException(String arg0) { + super(arg0); + // TODO Auto-generated constructor stub + } + + public FrameHasNotBeenLoadedException(Throwable arg0) { + super(arg0); + // TODO Auto-generated constructor stub + } + +} diff --git a/src/main/java/se/slackers/locality/exception/FrameIsTooOldException.java b/src/main/java/se/slackers/locality/exception/FrameIsTooOldException.java new file mode 100644 index 0000000..a1dafc3 --- /dev/null +++ b/src/main/java/se/slackers/locality/exception/FrameIsTooOldException.java @@ -0,0 +1,30 @@ +package se.slackers.locality.exception; + +public class FrameIsTooOldException extends RuntimeException { + + /** + * + */ + private static final long serialVersionUID = -3486181476553301458L; + + public FrameIsTooOldException() { + super(); + // TODO Auto-generated constructor stub + } + + public FrameIsTooOldException(String message, Throwable cause) { + super(message, cause); + // TODO Auto-generated constructor stub + } + + public FrameIsTooOldException(String message) { + super(message); + // TODO Auto-generated constructor stub + } + + public FrameIsTooOldException(Throwable cause) { + super(cause); + // TODO Auto-generated constructor stub + } + +} diff --git a/src/main/java/se/slackers/locality/exception/FrameStorageIsEmptyException.java b/src/main/java/se/slackers/locality/exception/FrameStorageIsEmptyException.java new file mode 100644 index 0000000..a0fd363 --- /dev/null +++ b/src/main/java/se/slackers/locality/exception/FrameStorageIsEmptyException.java @@ -0,0 +1,26 @@ +package se.slackers.locality.exception; + +public class FrameStorageIsEmptyException extends RuntimeException { + private static final long serialVersionUID = -5393933470236337451L; + + public FrameStorageIsEmptyException() { + super(); + // TODO Auto-generated constructor stub + } + + public FrameStorageIsEmptyException(String arg0, Throwable arg1) { + super(arg0, arg1); + // TODO Auto-generated constructor stub + } + + public FrameStorageIsEmptyException(String arg0) { + super(arg0); + // TODO Auto-generated constructor stub + } + + public FrameStorageIsEmptyException(Throwable arg0) { + super(arg0); + // TODO Auto-generated constructor stub + } + +} diff --git a/src/main/java/se/slackers/locality/exception/IllegalRequestException.java b/src/main/java/se/slackers/locality/exception/IllegalRequestException.java new file mode 100644 index 0000000..57f5b56 --- /dev/null +++ b/src/main/java/se/slackers/locality/exception/IllegalRequestException.java @@ -0,0 +1,30 @@ +package se.slackers.locality.exception; + +public class IllegalRequestException extends Exception { + + /** + * + */ + private static final long serialVersionUID = -8418140559118657718L; + + public IllegalRequestException() { + super(); + // TODO Auto-generated constructor stub + } + + public IllegalRequestException(String arg0, Throwable arg1) { + super(arg0, arg1); + // TODO Auto-generated constructor stub + } + + public IllegalRequestException(String arg0) { + super(arg0); + // TODO Auto-generated constructor stub + } + + public IllegalRequestException(Throwable arg0) { + super(arg0); + // TODO Auto-generated constructor stub + } + +} diff --git a/src/main/java/se/slackers/locality/exception/InvalidBufferPositionException.java b/src/main/java/se/slackers/locality/exception/InvalidBufferPositionException.java new file mode 100644 index 0000000..dcd571d --- /dev/null +++ b/src/main/java/se/slackers/locality/exception/InvalidBufferPositionException.java @@ -0,0 +1,25 @@ +package se.slackers.locality.exception; + +public class InvalidBufferPositionException extends RuntimeException { + + public InvalidBufferPositionException() { + super(); + // TODO Auto-generated constructor stub + } + + public InvalidBufferPositionException(String arg0, Throwable arg1) { + super(arg0, arg1); + // TODO Auto-generated constructor stub + } + + public InvalidBufferPositionException(String arg0) { + super(arg0); + // TODO Auto-generated constructor stub + } + + public InvalidBufferPositionException(Throwable arg0) { + super(arg0); + // TODO Auto-generated constructor stub + } + +} diff --git a/src/main/java/se/slackers/locality/media/Frame.java b/src/main/java/se/slackers/locality/media/Frame.java new file mode 100644 index 0000000..152d74c --- /dev/null +++ b/src/main/java/se/slackers/locality/media/Frame.java @@ -0,0 +1,88 @@ +package se.slackers.locality.media; + +public class Frame { + /** + * Frame length in ms + */ + private long length; + + /** + * Frame size in bytes + */ + private int size; + + /** + * Data buffer. + */ + private byte [] data; + + + public Frame() { + length = 0; + size = 0; + data = null; + } + + public Frame(int allocationSize) { + length = 0; + size = 0; + data = new byte[allocationSize]; + } + + /** + * Makes a deep copy of the given frame. + * @param frame + */ + public Frame(Frame frame) { + length = frame.length; + size = frame.size; + data = new byte[size]; + System.arraycopy(frame.data, 0, data, 0, size); + } + + /** + * Get the length of this frame in milliseconds + * @return Length of frame in Ms + */ + public long getLength() { + return length; + } + + public void setLength(long length) { + this.length = length; + } + + /** + * Get the size of the frame in bytes. + * @return Size of frame in bytes + */ + public int getSize() { + return size; + } + + public void setSize(int size) { + this.size = size; + } + + /** + * Returns a reference to the data + * @return + */ + public byte[] getData() { + return data; + } + + /** + * {@inheritDoc} + */ + @Override + public String toString() { + StringBuilder str = new StringBuilder(); + + str.append(getLength()); + str.append(" ms ["); + str.append(getSize()); + str.append(" bytes]"); + return str.toString(); + } +} diff --git a/src/main/java/se/slackers/locality/media/queue/AbstractMediaQueueProcessor.java b/src/main/java/se/slackers/locality/media/queue/AbstractMediaQueueProcessor.java new file mode 100644 index 0000000..6c82beb --- /dev/null +++ b/src/main/java/se/slackers/locality/media/queue/AbstractMediaQueueProcessor.java @@ -0,0 +1,254 @@ +package se.slackers.locality.media.queue; + +import java.io.IOException; +import java.lang.ref.WeakReference; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.concurrent.Semaphore; + +import org.apache.log4j.Logger; + +import se.slackers.locality.exception.EncapsuledExceptionRuntimException; +import se.slackers.locality.media.Frame; +import se.slackers.locality.media.reader.MediaReader; +import se.slackers.locality.media.reader.MediaReaderFactory; +import se.slackers.locality.media.reader.SilentMediaReader; +import se.slackers.locality.model.Media; +import se.slackers.locality.model.Metadata; + +public abstract class AbstractMediaQueueProcessor implements MediaQueueProcessor, Runnable { + private static final Logger log = Logger.getLogger(AbstractMediaQueueProcessor.class); + + private MediaQueue mediaQueue; + private MediaReader mediaReader = null; + private MediaReader silentReader = new SilentMediaReader(); + private MediaReaderFactory mediaReaderFactory = null; + + private List> mediaQueueProcessorListeners = new ArrayList>(); + + private boolean stopProcessing; + private int activeClients = 0; + + private Object stopProcessingMonitor = new Object(); + private Semaphore initDeinit = new Semaphore(1); + + + /** + * {@inheritDoc} + */ + public synchronized void init() { + log.info("Acquire permit"); + initDeinit.acquireUninterruptibly(); + + activeClients = 0; + stopProcessing = false; + + checkMediaReader(); + } + + /** + * {@inheritDoc} + */ + public synchronized void deinit() { + mediaQueue.getFrameStorage().clear(); + + if (mediaReader != null) { + try { + mediaReader.close(); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + mediaReader = null; + log.info("Releasing permit"); + initDeinit.release(); + } + + /** + * + */ + public void run() { + Frame frame = new Frame(3000); // Maximum frame size for an mp3 is 2881 + try { + while (stopProcessing == false) { + // If nothing is playing and there is nothing in the queue, exit the thread + if (mediaReader == null && mediaQueue.size() == 0) { + break; + } + + checkMediaReader(); + + // .. read a frame and store it in the buffer + if (mediaReader != null) { + synchronized (this) { + readData(mediaReader, frame); + } + } + } + // TODO: Fix the error handling + } catch (RuntimeException e) { + e.printStackTrace(); + } catch (Exception e) { + e.printStackTrace(); + } + + // Notify all waiting threads + if (stopProcessing) { + synchronized(stopProcessingMonitor) { + stopProcessingMonitor.notifyAll(); + } + } + } + + /** + * Makes sure that there is a valid {@link MediaReader} instantiated as long as there are more entries in the queue. + */ + private void checkMediaReader() { + if (mediaReader == null && mediaQueue.size() > 0) { + // create a new mediaReader for the next media file in queue. + mediaReader = mediaReaderFactory.getMediaReader(mediaQueue.get(0)); + try { + mediaReader.open(mediaQueue.get(0)); + fireNextMediaEvent(mediaQueue.get(0), mediaReader.getMetadata()); + } catch (IOException e) { + log.error("Can't open [" + mediaQueue.get(0) + "], skipping file"); + mediaQueue.remove(0); + } + } + + if (mediaReader != null && mediaReader.eof()) { + try { + mediaReader.close(); + mediaReader = null; + + // consume the played file + mediaQueue.remove(0); + + if (mediaQueue.size() > 0) { + // create a new mediaReader for the next media file in + // queue. + mediaReader = mediaReaderFactory.getMediaReader(mediaQueue.get(0)); + mediaReader.open(mediaQueue.get(0)); + fireNextMediaEvent(mediaQueue.get(0), mediaReader.getMetadata()); + } else { + mediaReader = silentReader; + } + } catch (IOException e) { + log.error("Can't open [" + mediaQueue.get(0) + "], skipping file"); + mediaQueue.remove(0); + } + } + } + + /** + * Reads a frame from the media and stores it in the FrameStorage. + * + * @param reader + * @param frame + * @return + */ + abstract protected void readData(MediaReader reader, Frame frame); + + /** + * Stops the processing and waits until it really has stopped. + */ + public void stopProcessing() { + this.stopProcessing = true; + + try { + synchronized(stopProcessingMonitor) { + stopProcessingMonitor.wait(); + } + } catch (InterruptedException e) { + throw new EncapsuledExceptionRuntimException(e); + } + + deinit(); + + mediaQueue.stopProcessor(); + } + + /** + * Returns the mediaQueue that is used by the processor + */ + public MediaQueue getMediaQueue() { + return mediaQueue; + } + + /** + * Sets the media queue to be used by the processor. This method also ensures that the reverse dependency is + * correct. + */ + public void setMediaQueue(MediaQueue mediaQueue) { + this.mediaQueue = mediaQueue; + if (this.mediaQueue.getMediaQueueProcessor() != this) { + this.mediaQueue.setMediaQueueProcessor(this); + } + } + + public MediaReaderFactory getMediaReaderFactory() { + return mediaReaderFactory; + } + + public void setMediaReaderFactory(MediaReaderFactory mediaReaderFactory) { + this.mediaReaderFactory = mediaReaderFactory; + } + + public void clientStartStreaming() { + activeClients++; + log.debug("Client connected, client="+activeClients); + + // Update metadata for the connected client + /* + if (mediaQueue != null && mediaReader != null) { + fireNextMediaEvent(mediaQueue.get(0), mediaReader.getMetadata()); + } + */ + } + + public void clientStopsStreaming() { + activeClients--; + log.debug("Client disconnected, client="+activeClients); + + if (activeClients == 0) { + // No clients listening, stop the stream + stopProcessing(); + } + } + + public void addMediaQueueProcessorListener(MediaQueueProcessorListener listener) { + log.debug("New listener added by thread "+Thread.currentThread()); + mediaQueueProcessorListeners.add(new WeakReference(listener)); + } + + public void removeMediaQueueProcessorListener(MediaQueueProcessorListener listener) { + mediaQueueProcessorListeners.remove(listener); + } + + /** + * Calls the nextMedia method in all registered MediaQueueListeners + * @param media + */ + protected void fireNextMediaEvent(Media media, Metadata metadata) { + Iterator> iterator = mediaQueueProcessorListeners.iterator(); + while (iterator.hasNext()) { + WeakReference ref = iterator.next(); + + if (null == ref.get()) { + iterator.remove(); + } else { + ref.get().nextMedia(media, metadata); + } + } + } + + + public Metadata getCurrentMetadata() { + if (mediaReader == null) { + return Metadata.create("Nothing playing", null, null); + } + return mediaReader.getMetadata(); + } +} diff --git a/src/main/java/se/slackers/locality/media/queue/MediaQueue.java b/src/main/java/se/slackers/locality/media/queue/MediaQueue.java new file mode 100644 index 0000000..df7e865 --- /dev/null +++ b/src/main/java/se/slackers/locality/media/queue/MediaQueue.java @@ -0,0 +1,31 @@ +package se.slackers.locality.media.queue; + +import se.slackers.locality.data.FrameStorage; +import se.slackers.locality.model.Media; + +public interface MediaQueue { + + /** + * Returns the name of the MediaQueue + * @return The name of the MediaQueue + */ + public String getName(); + + public void add(Media media); + public Media get(int index); + public void remove(int index); + public int size(); + + public void setMountPoint(String mountPoint); + public String getMountPoint(); + + public void startProcessor(); + public void stopProcessor(); + public boolean isProcessorRunning(); + + public MediaQueueProcessor getMediaQueueProcessor(); + public void setMediaQueueProcessor(MediaQueueProcessor queueProcessor); + + public FrameStorage getFrameStorage(); + public void setFrameStorage(FrameStorage frameStorage); +} diff --git a/src/main/java/se/slackers/locality/media/queue/MediaQueueImpl.java b/src/main/java/se/slackers/locality/media/queue/MediaQueueImpl.java new file mode 100644 index 0000000..a42506b --- /dev/null +++ b/src/main/java/se/slackers/locality/media/queue/MediaQueueImpl.java @@ -0,0 +1,123 @@ +package se.slackers.locality.media.queue; + +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; +import java.util.concurrent.Semaphore; + +import org.apache.log4j.Logger; + +import se.slackers.locality.data.FrameStorage; +import se.slackers.locality.model.Media; + +public class MediaQueueImpl implements MediaQueue { + private static final Logger log = Logger.getLogger(MediaQueueImpl.class); + + private String mountPoint; + private String queueName; + + private List queue; + + private Semaphore startStop = new Semaphore(1); + + private MediaQueueProcessor processor = null; + private FrameStorage frameStorage = null; + private Thread processorThread = null; + + public MediaQueueImpl(String queueName) { + this.queueName = queueName; + queue = Collections.synchronizedList(new LinkedList()); + } + + public MediaQueueProcessor getMediaQueueProcessor() { + return processor; + } + + /** + * Sets the MediaQueueProcessor to be used by the media queue. This method + * ensures that the reverse dependency is correct. + */ + public void setMediaQueueProcessor(MediaQueueProcessor processor) { + this.processor = processor; + + if (this.processor.getMediaQueue() != this) { + this.processor.setMediaQueue(this); + } + } + + public FrameStorage getFrameStorage() { + return frameStorage; + } + + public void setFrameStorage(FrameStorage frameStorage) { + this.frameStorage = frameStorage; + } + + /** + * Add media to the queue. + * @param media + */ + public void add(Media media) { + queue.add(media); + } + + /** + * Returns media from a certain position in the queue. + */ + public Media get(int index) { + return queue.get(index); + } + + public void remove(int index) { + if (!queue.isEmpty()) { + queue.remove(index); + } + } + + public int size() { + return queue.size(); + } + + public String getMountPoint() { + return mountPoint; + } + + public void setMountPoint(String mountPoint) { + this.mountPoint = mountPoint; + } + + public synchronized boolean isProcessorRunning() { + if (processorThread == null) + return false; + + return processorThread.isAlive(); + } + + public synchronized void startProcessor() { + log.info("Waiting to start processor ["+(processorThread == null || processorThread.isAlive() == false)+"]"); + startStop.acquireUninterruptibly(); + log.info("Starting processor ["+(processorThread == null || processorThread.isAlive() == false)+"]"); + + if (processorThread == null || processorThread.isAlive() == false) { + processor.init(); + processorThread = new Thread(processor, "QueueProcessor["+getMountPoint()+"]"); + processorThread.start(); + } + } + + public void stopProcessor() { +/* + if (isProcessorRunning()) { + processor.stopProcessing(); + processor.deinit(); + processorThread = null; + } +*/ + log.info("Releasing startStop lock"); + startStop.release(); + } + + public String getName() { + return queueName; + } +} diff --git a/src/main/java/se/slackers/locality/media/queue/MediaQueueProcessor.java b/src/main/java/se/slackers/locality/media/queue/MediaQueueProcessor.java new file mode 100644 index 0000000..cdc23e5 --- /dev/null +++ b/src/main/java/se/slackers/locality/media/queue/MediaQueueProcessor.java @@ -0,0 +1,31 @@ +package se.slackers.locality.media.queue; + +import se.slackers.locality.media.reader.MediaReaderFactory; +import se.slackers.locality.model.Metadata; +import se.slackers.locality.shout.ClientListener; + +/** + * + * @author bysse + * + */ +public interface MediaQueueProcessor extends Runnable, ClientListener { + public void init(); + public void deinit(); + + /** + * Stop the processor and wait until it really is stopped. + */ + public void stopProcessing(); + + public void setMediaQueue(MediaQueue mediaQueue); + public MediaQueue getMediaQueue(); + + public void setMediaReaderFactory(MediaReaderFactory mediaReaderFactory); + public MediaReaderFactory getMediaReaderFactory(); + + public void addMediaQueueProcessorListener(MediaQueueProcessorListener listener); + public void removeMediaQueueProcessorListener(MediaQueueProcessorListener listener); + + public Metadata getCurrentMetadata(); +} diff --git a/src/main/java/se/slackers/locality/media/queue/MediaQueueProcessorListener.java b/src/main/java/se/slackers/locality/media/queue/MediaQueueProcessorListener.java new file mode 100644 index 0000000..c34c0d2 --- /dev/null +++ b/src/main/java/se/slackers/locality/media/queue/MediaQueueProcessorListener.java @@ -0,0 +1,14 @@ +package se.slackers.locality.media.queue; + +import se.slackers.locality.model.Media; +import se.slackers.locality.model.Metadata; + +public interface MediaQueueProcessorListener { + + /** + * Called when the MediaQueue advances to the next Media in queue. + * @param media The media that will be played. + * @param metadata The metadata for the media + */ + public void nextMedia(Media media, Metadata metadata); +} diff --git a/src/main/java/se/slackers/locality/media/queue/PreloadDataMediaQueueProcessor.java b/src/main/java/se/slackers/locality/media/queue/PreloadDataMediaQueueProcessor.java new file mode 100644 index 0000000..fbc5a06 --- /dev/null +++ b/src/main/java/se/slackers/locality/media/queue/PreloadDataMediaQueueProcessor.java @@ -0,0 +1,67 @@ +package se.slackers.locality.media.queue; + +import java.io.IOException; + +import org.apache.log4j.Logger; + +import se.slackers.locality.data.FrameStorage; +import se.slackers.locality.data.FrameStorageEntry; +import se.slackers.locality.exception.EncapsuledExceptionRuntimException; +import se.slackers.locality.exception.FrameStorageIsEmptyException; +import se.slackers.locality.media.Frame; +import se.slackers.locality.media.reader.MediaReader; + +public class PreloadDataMediaQueueProcessor extends AbstractMediaQueueProcessor { + private static final Logger log = Logger.getLogger(PreloadDataMediaQueueProcessor.class); + + private long maximumPreload = 5000; + private long maximumHistory = 5000; + + private void sleep(long ms) { + try { + Thread.sleep(ms); + } catch (InterruptedException e) { + throw new EncapsuledExceptionRuntimException(e); + } + } + + /** + * {@inheritDoc} + */ + protected void readData(MediaReader reader, Frame frame) { + FrameStorage storage = getMediaQueue().getFrameStorage(); + + long currentTime = System.currentTimeMillis(); + long lastFrameTime = currentTime; + + // first purge the history + storage.purgeUntil(currentTime - maximumHistory); + + try { + lastFrameTime = storage.getLastFrameTime(); + + // Make sure we don't use old time stamps when we store frames + if (lastFrameTime < currentTime) { + lastFrameTime = currentTime; + log.warn("FrameReader is lagging"); + } + + } catch (FrameStorageIsEmptyException e) { + // do nothing + } + + if (lastFrameTime > currentTime + maximumPreload) { + // the maximum data preload have been reached, stall the thread for a while. + sleep(250); + return; + } + + //.. read more data from the media + try { + reader.readFrame(frame); + storage.add( new FrameStorageEntry(lastFrameTime, new Frame(frame) ) ); + } catch (IOException e) { + throw new EncapsuledExceptionRuntimException(e); + } + } +} diff --git a/src/main/java/se/slackers/locality/media/reader/ByteStreamReader.java b/src/main/java/se/slackers/locality/media/reader/ByteStreamReader.java new file mode 100644 index 0000000..f56727f --- /dev/null +++ b/src/main/java/se/slackers/locality/media/reader/ByteStreamReader.java @@ -0,0 +1,133 @@ +package se.slackers.locality.media.reader; + +import java.io.EOFException; +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; + +import org.apache.log4j.Logger; + + + +public class ByteStreamReader { + private static final Logger log = Logger.getLogger(ByteStreamReader.class); + + private InputStream inputStream = null; + private ByteBuffer buffer = null; + private byte[] tempbuffer = null; + + private int readIndex = 0; + private int writeIndex = 0; + private int indexOffset = 0; + + public ByteStreamReader() { +// buffer = ByteBuffer.allocateDirect(1024*1024); +// tempbuffer = new byte[65536]; + buffer = ByteBuffer.allocateDirect(1024*1024); + tempbuffer = new byte[65536]; + } + + /** + * Returns the position of the read-cursor + * @return + */ + public int getOffset() { + return indexOffset + readIndex; + } + + /** + * Gets one byte from the current position. + * @return + * @throws IOException + */ + public byte read() throws IOException { + if (readIndex >= writeIndex) { + if (0 == readData()) { + throw new EOFException(); + } + } + + return buffer.get(readIndex++); + } + + /** + * + * @param destbuffer + * @param offset + * @param length + * @throws IOException + */ + public void read(byte [] destbuffer, int offset, int length) throws IOException { + assert length < tempbuffer.length : "The requested data is bigger than the tempbuffer"; + + if (readIndex + length >= writeIndex) { + if (0 == readData()) { + throw new EOFException(); + } + } + + buffer.position(readIndex); + buffer.get(destbuffer, offset, length); + readIndex += length; + } + + private int readData() throws IOException { + if (buffer.limit() - writeIndex < tempbuffer.length) { + recycleBuffer(); + } + + int bytes = inputStream.read(tempbuffer, 0, tempbuffer.length); + + buffer.position(writeIndex); + buffer.put(tempbuffer, 0, bytes); + writeIndex += bytes; + + log.info("[" + bytes + " bytes read]"); + + return bytes; + } + + /** + * Recycle the buffer + */ + private void recycleBuffer() { + if (readIndex <= 0) { + return; + } + + log.info("Recycling ByteBuffer"); + + int indexAdjustment = readIndex; + int recycleIndex = 0; + + // the data that is to be recycled is larger than tempbuffer + while (writeIndex - readIndex > tempbuffer.length) { + buffer.position(readIndex); + buffer.get(tempbuffer, 0, tempbuffer.length); + buffer.position(recycleIndex); + buffer.put(tempbuffer, 0, tempbuffer.length); + + recycleIndex += tempbuffer.length; + readIndex += tempbuffer.length; + } + + if (writeIndex - readIndex > 0) { + buffer.position(readIndex); + buffer.get(tempbuffer, 0, writeIndex - readIndex); + buffer.position(recycleIndex); + buffer.put(tempbuffer, 0, writeIndex - readIndex); + } + + indexOffset += indexAdjustment; + writeIndex -= indexAdjustment; + readIndex = 0; + } + + public InputStream getInputStream() { + return inputStream; + } + + public void setInputStream(InputStream inputStream) { + this.inputStream = inputStream; + } +} diff --git a/src/main/java/se/slackers/locality/media/reader/ByteUtils.java b/src/main/java/se/slackers/locality/media/reader/ByteUtils.java new file mode 100644 index 0000000..dc8f78a --- /dev/null +++ b/src/main/java/se/slackers/locality/media/reader/ByteUtils.java @@ -0,0 +1,24 @@ +package se.slackers.locality.media.reader; + +public class ByteUtils { + /** + * Converts a byte to a string of ones and zeroes. + * @param b + * @return + */ + public static String byte2String(byte b) { + StringBuffer sb = new StringBuffer(); + + int value = 0x80; + for (int i = 0; i < 8; i++) { + if ((b & value) == 0) { + sb.append("0"); + } else { + sb.append("1"); + } + value >>= 1; + } + + return sb.toString(); + } +} diff --git a/src/main/java/se/slackers/locality/media/reader/MediaReader.java b/src/main/java/se/slackers/locality/media/reader/MediaReader.java new file mode 100644 index 0000000..abe95d1 --- /dev/null +++ b/src/main/java/se/slackers/locality/media/reader/MediaReader.java @@ -0,0 +1,51 @@ +package se.slackers.locality.media.reader; + +import java.io.IOException; + +import se.slackers.locality.media.Frame; +import se.slackers.locality.model.Media; +import se.slackers.locality.model.Metadata; + +public interface MediaReader { + /** + * Returns true if this reader supports the format of the given media. + * @param media + * @return + */ + public boolean supports(Media media); + + /** + * Opens the media file. + * @param media + * @throws IOException + */ + public void open(Media media) throws IOException ; + + /** + * Reads one frame of the media. + * @param frame + * @return + * @throws IOException + */ + public Frame readFrame(Frame frame) throws IOException; + + /** + * Closes the media. + * @throws IOException + */ + public void close() throws IOException; + + /** + * Returns true if the end of the media is reached. + * @return + */ + public boolean eof(); + + /** + * Returns information about the media, artist, title. This function can be + * called multiple times but it only needs to have valid metadata after open has + * been called. It must never return null. + * @return + */ + public Metadata getMetadata(); +} diff --git a/src/main/java/se/slackers/locality/media/reader/MediaReaderFactory.java b/src/main/java/se/slackers/locality/media/reader/MediaReaderFactory.java new file mode 100644 index 0000000..0da4036 --- /dev/null +++ b/src/main/java/se/slackers/locality/media/reader/MediaReaderFactory.java @@ -0,0 +1,36 @@ +package se.slackers.locality.media.reader; + +import java.util.ArrayList; +import java.util.List; + +import se.slackers.locality.exception.CantCreateMediaReaderException; +import se.slackers.locality.model.Media; + +public class MediaReaderFactory { + private List mediaReaders = new ArrayList(); + + public void addMediaReader(MediaReader mediaReader) { + mediaReaders.add(mediaReader); + } + + /** + * Creates a MediaReader that can handle the given media file. + * @throws CantCreateMediaReaderException + * @param media + * @return + */ + public MediaReader getMediaReader(Media media) { + for (MediaReader reader : mediaReaders) { + if (reader.supports(media)) { + try { + return (MediaReader) reader.getClass().newInstance(); + } catch (InstantiationException e) { + throw new CantCreateMediaReaderException(e); + } catch (IllegalAccessException e) { + throw new CantCreateMediaReaderException(e); + } + } + } + throw new CantCreateMediaReaderException("No supported reader found for the media file ["+media.getMediaFile()+"]"); + } +} diff --git a/src/main/java/se/slackers/locality/media/reader/SilentMediaReader.java b/src/main/java/se/slackers/locality/media/reader/SilentMediaReader.java new file mode 100644 index 0000000..9d63062 --- /dev/null +++ b/src/main/java/se/slackers/locality/media/reader/SilentMediaReader.java @@ -0,0 +1,43 @@ +package se.slackers.locality.media.reader; + +import java.io.IOException; + +import se.slackers.locality.media.Frame; +import se.slackers.locality.model.Media; +import se.slackers.locality.model.Metadata; + +public class SilentMediaReader implements MediaReader { + + byte [] emptyFrame = new byte[] {(byte) 0xff, (byte) 0xf2, 0x10, (byte) 0xc4, 0x1b, 0x27, 0x0, 0x0, 0x0, 0x3, (byte) 0xfc, 0x0, 0x0, 0x0, 0x0, 0x4c, 0x41, 0x4d, 0x45, 0x33, 0x2e, 0x39, 0x37, 0x0, 0x0, 0x0, (byte) 0xff, (byte) 0xf2, 0x10, (byte) 0xc4, 0x1b, 0x27, 0x0, 0x0, 0x0, 0x3, (byte) 0xfc, 0x0, 0x0, 0x0, 0x0, 0x4c, 0x41, 0x4d, 0x45, 0x33, 0x2e, 0x39, 0x37, 0x0, 0x0, 0x0}; + + public void close() throws IOException { + } + + public boolean eof() { + return true; + } + + public void open(Media media) throws IOException { + } + + public Frame readFrame(Frame frame) throws IOException { + + frame.setLength(26); + frame.setSize(emptyFrame.length); + System.arraycopy(emptyFrame, 0, frame.getData(), 0, emptyFrame.length); + + return frame; + } + + /** + * This method always returns false so the reader isn't used by mistake. + */ + public boolean supports(Media media) { + return false; + } + + public Metadata getMetadata() { + return Metadata.create("", "", "No media playing"); + } + +} diff --git a/src/main/java/se/slackers/locality/media/reader/mp3/Mp3FrameHeader.java b/src/main/java/se/slackers/locality/media/reader/mp3/Mp3FrameHeader.java new file mode 100644 index 0000000..378b533 --- /dev/null +++ b/src/main/java/se/slackers/locality/media/reader/mp3/Mp3FrameHeader.java @@ -0,0 +1,136 @@ +package se.slackers.locality.media.reader.mp3; + + +public class Mp3FrameHeader { + //private static final Logger log = Logger.getLogger(Mp3FrameHeader.class); + + private byte header[] = new byte[4]; + private long offset; + + // DUMMY, MPEG1, MPEG2, MPEG2.5 + private static final int sampleRateTable[][] = { + { 0, 44100, 22050, 11025 }, { 0, 48000, 24000, 12000 }, + { 0, 32000, 16000, 8000 }, { 0, 0, 0, 0 } }; + + // V1 L1, V1 L2, V1 L3, V2 L1, V2 L2 & L3 + private static final int bitRateTable[][] = { { 0, 0, 0, 0, 0 }, + { 32, 32, 32, 32, 8 }, { 64, 48, 40, 48, 16 }, + { 96, 56, 48, 56, 24 }, { 128, 64, 56, 64, 32 }, + { 160, 80, 64, 80, 40 }, { 192, 96, 80, 96, 48 }, + { 224, 112, 96, 112, 56 }, { 256, 128, 112, 128, 64 }, + { 288, 160, 128, 144, 80 }, { 320, 192, 160, 160, 96 }, + { 352, 224, 192, 176, 112 }, { 384, 256, 224, 192, 128 }, + { 416, 320, 256, 224, 144 }, { 448, 384, 320, 256, 160 }, + { 0, 0, 0, 0, 0 } }; + + public Mp3FrameHeader() { + } + + public void setData(byte [] data) { + for (int i = 0; i < 4; i++) { + header[i] = data[i]; + } + } + + public void setData(byte b1, byte b2, byte b3, byte b4) { + header[0] = b1; + header[1] = b2; + header[2] = b3; + header[3] = b4; + } + + public byte [] getData() { + return header; + } + + /* + * 7 6 5 4 3 2 1 0 128 64 32 16 8 4 2 1 0x80 0x40 0x20 0x10 0x08 0x04 0x02 + * 0x01 + * + * A = 10 B = 11 C = 12 D = 13 E = 14 F = 15 + */ + + public int getMPEGVersion() { + return 4 - ((header[1] & 0x18) >> 3); + } + + public int getLayerDescription() { + return 4 - ((header[1] & 0x06) >> 1); + } + + public boolean isCRCProtected() { + return (header[1] & 0x01) == 1; + } + + public int getBitRate() { + int index = (header[2] & 0xf0) >> 4; + + int v = getMPEGVersion(); + int l = getLayerDescription(); + + int index2 = Math.min((v - 1) * 3 + (l - 1), 4); + + return bitRateTable[index][index2] * 1000; + } + + public boolean isPadded() { + return (header[2] & 0x2) == 2; + } + + public int getSampleRate() { + int index = (header[2] & 0x0e) >> 2; + if (index < 0 || index > 3) { + return 0; + } + int version = getMPEGVersion(); + return sampleRateTable[index][version]; + } + + public int getChannelMode() { + return ((header[3] & 0xC0) >> 6); + } + + public int getModeExtension() { + return ((header[3] & 0x30) >> 4); + } + + public boolean isCopyrighted() { + return (header[3] & 0x08) != 0; + } + + public boolean isOriginal() { + return (header[3] & 0x04) != 0; + } + + public int getEmphasis() { + return (header[3] & 0x03); + } + + public int getFrameSize() { + int bitrate = getBitRate(); + int samplerate = getSampleRate(); + int padding = isPadded() ? 1 : 0; + return 144 * bitrate / (samplerate + padding); + } + + public String toString() { + return "Mp3Header[" + offset + "] {" + "\n MPEG Version: " + + getMPEGVersion() + "\n Layer description: " + + getLayerDescription() + "\n Is CRC protected: " + + isCRCProtected() + "\n Bitrate: " + getBitRate() + + "\n Samplerate: " + getSampleRate() + "\n Is Padded: " + + isPadded() + "\n Channel mode: " + getChannelMode() + + "\n Mode Extension: " + getModeExtension() + "\n Copyright: " + + isCopyrighted() + "\n Is original: " + isOriginal() + + "\n Emphasis: " + getEmphasis() + "\n Frame size: " + + getFrameSize() + "\n}"; + } + + public long getOffset() { + return offset; + } + + public void setOffset(long offset) { + this.offset = offset; + } +} diff --git a/src/main/java/se/slackers/locality/media/reader/mp3/Mp3MediaReader.java b/src/main/java/se/slackers/locality/media/reader/mp3/Mp3MediaReader.java new file mode 100644 index 0000000..ef8bcd8 --- /dev/null +++ b/src/main/java/se/slackers/locality/media/reader/mp3/Mp3MediaReader.java @@ -0,0 +1,133 @@ +package se.slackers.locality.media.reader.mp3; + +import java.io.FileInputStream; +import java.io.IOException; + +import org.apache.log4j.Logger; +import org.jaudiotagger.audio.AudioFile; +import org.jaudiotagger.audio.AudioFileIO; +import org.jaudiotagger.tag.Tag; + +import se.slackers.locality.media.Frame; +import se.slackers.locality.media.reader.ByteStreamReader; +import se.slackers.locality.media.reader.MediaReader; +import se.slackers.locality.model.Media; +import se.slackers.locality.model.Metadata; +import se.slackers.locality.model.MetadataType; + +/* + * 128kbps 44.1kHz layer II uses a lot of 418 bytes and some of 417 bytes long. + * Regardless of the bitrate of the file, a frame in an MPEG-1 file lasts for 26ms (26/1000 of a second). + */ +public class Mp3MediaReader implements MediaReader { + private static final Logger log = Logger.getLogger(Mp3MediaReader.class); + + private ByteStreamReader reader = null; + private Mp3FrameHeader header = new Mp3FrameHeader(); + private Metadata metadata = null; + + public Mp3MediaReader() { + super(); + + metadata = Metadata.create("Unknown", "", ""); + } + + /** + * {@inheritDoc} + */ + public boolean supports(Media media) { + return media.getMediaFile().toString().toLowerCase().endsWith(".mp3"); + } + + /** + * {@inheritDoc} + */ + public void close() throws IOException { + if (reader != null) { + reader.getInputStream().close(); + reader.setInputStream(null); + reader = null; + } + } + + /** + * {@inheritDoc} + */ + public void open(Media media) throws IOException { + if (reader != null) { + close(); + } + + reader = new ByteStreamReader(); + reader.setInputStream(new FileInputStream(media.getMediaFile())); + + // try to read some id3 tags from the media + try { + AudioFile audioFile = AudioFileIO.read(media.getMediaFile()); + Tag tag = audioFile.getTag(); + + metadata.set(MetadataType.ARTIST, tag.getFirstArtist() ); + metadata.set(MetadataType.ALBUM, tag.getFirstAlbum() ); + metadata.set(MetadataType.TITLE, tag.getFirstTitle() ); + + log.info("Opening "+metadata); + } catch (Exception e) { + log.error("Can't read tag from "+media); + e.printStackTrace(); + } + + } + + /** + * {@inheritDoc} + */ + public boolean eof() { + try { + return reader.getInputStream().available() <= 0; + } catch (IOException e) { + return true; + } + } + + /** + * {@inheritDoc} + */ + public Frame readFrame(Frame frame) throws IOException { + Mp3FrameHeader header = findMp3Header(); + //log.info(header.toString()); + + frame.setSize(header.getFrameSize()); + frame.setLength(26); + + System.arraycopy(header.getData(), 0, frame.getData(), 0, 4); + reader.read(frame.getData(), 4, (int)frame.getSize()-4); + + return frame; + } + + /** + * {@inheritDoc} + */ + public Metadata getMetadata() { + return metadata; + } + + private Mp3FrameHeader findMp3Header() throws IOException { + byte lastByte = 0; + byte currentByte = 0; + + while (true) { + lastByte = currentByte; + currentByte = reader.read(); + // Check for the start of the Mp3 Frame Header + if (lastByte == (byte) 0xff && (currentByte & 0xE0) == 0xE0) { + header.setOffset(reader.getOffset() - 2); + header.setData(lastByte, currentByte, reader.read(), reader.read()); + + //log.info("Found frame start at index [" + (header.getOffset()) + // + "]"); + return header; + } + } + } +} diff --git a/src/main/java/se/slackers/locality/model/Media.java b/src/main/java/se/slackers/locality/model/Media.java new file mode 100644 index 0000000..a973f62 --- /dev/null +++ b/src/main/java/se/slackers/locality/model/Media.java @@ -0,0 +1,20 @@ +package se.slackers.locality.model; + +import java.io.File; + +public class Media { + private File mediaFile; + + public File getMediaFile() { + return mediaFile; + } + + public void setMediaFile(File mediaFile) { + this.mediaFile = mediaFile; + } + + @Override + public String toString() { + return "Media: "+mediaFile.toString(); + } +} diff --git a/src/main/java/se/slackers/locality/model/MetaTag.java b/src/main/java/se/slackers/locality/model/MetaTag.java new file mode 100755 index 0000000..b46d02f --- /dev/null +++ b/src/main/java/se/slackers/locality/model/MetaTag.java @@ -0,0 +1,122 @@ +package se.slackers.locality.model; + +import java.util.ArrayList; +import java.util.List; + +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.ManyToMany; + +/** + * + * @author eb + * + */ +@Entity +public class MetaTag { + private Long id; + private String name; + private List tags; + + /** + * + */ + public MetaTag() { + id = new Long(0); + name = ""; + tags = new ArrayList(); + } + + /** + * Adds a metatag to the specified tag. This method fixes the the bidirectional dependency. + * @see Tag#addMetaTag(MetaTag) + * @param tag + */ + public void addTag(Tag tag) { + assert tag != null : "The given tag is null"; + + getTags().add(tag); + tag.getMetaTags().add(this); + } + + /** + * + * @return + */ + @Id + @Column(name = "id", unique = true) + @GeneratedValue(strategy = GenerationType.AUTO) + public Long getId() { + return id; + } + + /** + * + * @return + */ + @Basic + @Column(name = "name", unique = true) + public String getName() { + return name; + } + + /** + * + * @return + */ + @ManyToMany(targetEntity = Tag.class, cascade = { CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH }) + @JoinTable(name = "MetaTag_Tag", joinColumns = @JoinColumn(name = "MetaTag_id", referencedColumnName = "id"), inverseJoinColumns = @JoinColumn(name = "Tag_id", referencedColumnName = "id")) + public List getTags() { + return tags; + } + + /** + * + * @param tag + */ + public void removeTag(Tag tag) { + assert tag != null : "The given tag is null"; + + getTags().remove(tag); + tag.getMetaTags().remove(this); + } + + /** + * + * @param id + */ + public void setId(Long id) { + this.id = id; + } + + /** + * + * @param name + */ + public void setName(String name) { + this.name = name; + } + + /** + * + * @param tags + */ + public void setTags(List tags) { + this.tags = tags; + } + + /** + * {@inheritDoc} + */ + public String toString() { + int num = tags == null ? 0 : tags.size(); + return "MetaTag [id:"+id+", name:"+name+", tags: "+num+"]"; + } +} diff --git a/src/main/java/se/slackers/locality/model/Metadata.java b/src/main/java/se/slackers/locality/model/Metadata.java new file mode 100644 index 0000000..90dca94 --- /dev/null +++ b/src/main/java/se/slackers/locality/model/Metadata.java @@ -0,0 +1,52 @@ +package se.slackers.locality.model; + +import java.util.HashMap; +import java.util.Map; + +/** + * Holds some basic information about a media file. + * @author bysse + * + */ +public class Metadata { + private Map data = new HashMap(); + + public static Metadata create(String artist, String album, String title) { + Metadata info = new Metadata(); + + info.set(MetadataType.ARTIST, artist); + info.set(MetadataType.ALBUM, album); + info.set(MetadataType.TITLE, title); + + return info; + } + + public void set(MetadataType type, String value) { + data.put(type, value); + } + + public boolean has(MetadataType type) { + return data.containsKey(type); + } + + public String get(MetadataType type) { + return data.get(type); + } + + @Override + public String toString() { + StringBuffer builder = new StringBuffer(); + + builder.append("["); + for (MetadataType type : data.keySet()) { + builder.append(data.get(type)); + builder.append(", "); + } + if (builder.length() > 0) { + builder.setLength(builder.length()-1); + } + builder.append("]"); + + return builder.toString(); + } +} diff --git a/src/main/java/se/slackers/locality/model/MetadataType.java b/src/main/java/se/slackers/locality/model/MetadataType.java new file mode 100644 index 0000000..8d256fa --- /dev/null +++ b/src/main/java/se/slackers/locality/model/MetadataType.java @@ -0,0 +1,8 @@ +package se.slackers.locality.model; + +public enum MetadataType { + ARTIST, + ALBUM, + TRACK, + TITLE +} diff --git a/src/main/java/se/slackers/locality/model/Tag.java b/src/main/java/se/slackers/locality/model/Tag.java new file mode 100755 index 0000000..80c9071 --- /dev/null +++ b/src/main/java/se/slackers/locality/model/Tag.java @@ -0,0 +1,122 @@ +package se.slackers.locality.model; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; + +import javax.persistence.Basic; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.ManyToMany; + +/** + * + * @author eb + * + */ +@Entity +public class Tag implements Serializable { + private static final long serialVersionUID = 825416798925249763L; + + private Long id; + private String name; + private List metaTags; + + /** + * + */ + public Tag() { + id = new Long(0); + name = ""; + metaTags = new ArrayList(); + } + + /** + * Adds a metatag to the tag. This method also fixes the the bidirectional dependency. + * @see MetaTag#addTag(Tag) + * @param metatag + */ + public void addMetaTag(MetaTag metatag) { + assert metatag != null : "The given meta tag is null"; + + getMetaTags().add(metatag); + metatag.getTags().add(this); + } + + /** + * + * @return + */ + @Id + @Column(name = "id", unique = true) + @GeneratedValue(strategy = GenerationType.AUTO) + public Long getId() { + return id; + } + + /** + * + * @return + */ + @ManyToMany(targetEntity = MetaTag.class, cascade = { CascadeType.PERSIST, CascadeType.MERGE }, mappedBy = "tags") + public List getMetaTags() { + return metaTags; + } + + /** + * + * @return + */ + @Basic + @Column(name = "name", unique = true) + public String getName() { + return name; + } + + /** + * + * @param metatag + */ + public void removeMetaTag(MetaTag metatag) { + assert metatag != null : "The given meta tag is null"; + + getMetaTags().remove(metatag); + metatag.getTags().remove(this); + } + + /** + * + * @param id + */ + public void setId(Long id) { + this.id = id; + } + + /** + * + * @param metaTags + */ + public void setMetaTags(List metaTags) { + this.metaTags = metaTags; + } + + /** + * + * @param name + */ + public void setName(String name) { + this.name = name; + } + + /** + * {@inheritDoc} + */ + public String toString() { + int num = metaTags == null ? 0 : metaTags.size(); + return "Tag [id:" + id + ", name:" + name + ", metatags: " + num + "]"; + } +} diff --git a/src/main/java/se/slackers/locality/net/HttpRequest.java b/src/main/java/se/slackers/locality/net/HttpRequest.java new file mode 100644 index 0000000..ddc72fa --- /dev/null +++ b/src/main/java/se/slackers/locality/net/HttpRequest.java @@ -0,0 +1,32 @@ +package se.slackers.locality.net; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import se.slackers.locality.exception.IllegalRequestException; + +public class HttpRequest { + private static final Pattern getRegexp = Pattern.compile("get\\s+([^\\s]+).*", Pattern.CASE_INSENSITIVE | Pattern.DOTALL); + private String request; + + public HttpRequest(String request) { + this.request = request; + } + + public String getRequestPath() throws IllegalRequestException { + Matcher matcher = getRegexp.matcher(request); + + if (matcher.matches()) { + return matcher.group(1); + } + + throw new IllegalRequestException("Illegal request ["+request+"]"); + } + + /** + * {@inheritDoc} + */ + public String toString() { + return request; + } +} diff --git a/src/main/java/se/slackers/locality/shout/ClientListener.java b/src/main/java/se/slackers/locality/shout/ClientListener.java new file mode 100644 index 0000000..3086953 --- /dev/null +++ b/src/main/java/se/slackers/locality/shout/ClientListener.java @@ -0,0 +1,14 @@ +package se.slackers.locality.shout; + +public interface ClientListener { + /** + * Called whenever a new ShoutRunnable is started to handle a client connection. + */ + public void clientStartStreaming(); + + /** + * Called when a a ShoutRunnable is stopped. + */ + public void clientStopsStreaming(); + +} diff --git a/src/main/java/se/slackers/locality/shout/ShoutRunnable.java b/src/main/java/se/slackers/locality/shout/ShoutRunnable.java new file mode 100644 index 0000000..d767add --- /dev/null +++ b/src/main/java/se/slackers/locality/shout/ShoutRunnable.java @@ -0,0 +1,267 @@ +package se.slackers.locality.shout; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.lang.ref.WeakReference; +import java.net.Socket; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import org.apache.log4j.Logger; + +import se.slackers.locality.data.FrameStorage; +import se.slackers.locality.data.FrameStorageEntry; +import se.slackers.locality.data.MetadataManager; +import se.slackers.locality.exception.EncapsuledExceptionRuntimException; +import se.slackers.locality.exception.FrameHasNotBeenLoadedException; +import se.slackers.locality.exception.FrameIsTooOldException; +import se.slackers.locality.exception.FrameStorageIsEmptyException; +import se.slackers.locality.media.Frame; +import se.slackers.locality.media.queue.MediaQueue; +import se.slackers.locality.net.HttpRequest; +import se.slackers.locality.shout.manager.ShoutRequestManager; + +public class ShoutRunnable implements Runnable { + private static Logger log = Logger.getLogger(ShoutRunnable.class); + private static final int metadataInterval = 65536; + + private Socket socket; + private ShoutRequestManager requestManager; + private MetadataManager metadataManager; + + protected boolean exit; + private List> clientConnectionListeners = new ArrayList>(); + + public ShoutRunnable(ShoutRequestManager requestManager, Socket clientSocket) { + this.socket = clientSocket; + this.requestManager = requestManager; + this.metadataManager = new MetadataManager(); + } + + public void run() { + log.info(Thread.currentThread().getName() + " started"); + try { + InputStream in = socket.getInputStream(); + OutputStream out = socket.getOutputStream(); + + HttpRequest request = readRequest(in); + log.info("Received request: "+request); + + MediaQueue mediaQueue = null; + try { + mediaQueue = requestManager.processRequest(request); + } catch (SecurityException e) { + writeNegativeResponse(out); + + //TODO: Change the execution flow of this method + throw new IOException("Change this code please"); + } + + sendStartStreamResponse(mediaQueue, out); + + mediaQueue.startProcessor(); + mediaQueue.getMediaQueueProcessor().addMediaQueueProcessorListener(metadataManager); + + metadataManager.setMetadata(mediaQueue.getMediaQueueProcessor().getCurrentMetadata()); + addClientConnectionListener(mediaQueue.getMediaQueueProcessor()); + + fireClientStartsStreaming(); + + FrameStorage storage = mediaQueue.getFrameStorage(); + + FrameStorageEntry entry = null; + long time = System.currentTimeMillis(); + int bytesSent = 0; + int total = 0; + + while (true) { + try { + entry = storage.find(time); + time = entry.getStopTime(); + + // grab the next frame to send + Frame frame = entry.getFrame(); + + // Check if we have to send metadata + if (bytesSent + frame.getSize() >= metadataInterval) { + + int sendBefore = metadataInterval - bytesSent; + if (sendBefore > 0) { + out.write(frame.getData(), 0, sendBefore); + } + + byte [] metadata = metadataManager.getMetaData(mediaQueue); + out.write(metadata); + + out.write(frame.getData(), sendBefore, frame.getSize()-sendBefore); + bytesSent -= metadataInterval; + } else { + // we don't need to send any meta data + //log.debu + out.write(entry.getFrame().getData(), 0, entry.getFrame().getSize()); + } + + bytesSent += frame.getSize(); + total += frame.getSize(); + + } catch (FrameStorageIsEmptyException e) { + // sleep for a while and let the MediaQueueProcessor fill the storage + sleep(250); + } catch (FrameIsTooOldException e) { + // the client is lagging behind. Reset the time to the current system time. + time = System.currentTimeMillis(); + } catch (FrameHasNotBeenLoadedException e) { + // the client is too far ahead. + //log.info("Client is too far ahead, sleeping 250 Ms"); + sleep(250); + } + } + + } catch(IOException e) { + e.printStackTrace(); + // TODO: Fix error handling + } catch(RuntimeException e) { + e.printStackTrace(); + // TODO: Fix error handling + } + + fireClientStopsStreaming(); + + setExit(true); + log.info(Thread.currentThread().getName() + " stopped"); + } + + private void writeNegativeResponse(OutputStream out) throws IOException { + out.write( (new String("404 Not found")).getBytes() ); + } + + private void sendStartStreamResponse(MediaQueue mediaQueue, OutputStream out) throws IOException { + StringBuilder response = new StringBuilder(); + response.append("HTTP/1.1 200 OK\r\nContent-Type: audio/mpeg\r\n"); + + // add the stream name + response.append("icy-name: "); + response.append(mediaQueue.getName()); + response.append("\r\n"); + + // add metadata information + response.append("icy-metadata:1\r\n"); + response.append("icy-metaint:"); + response.append(metadataInterval); + response.append("\r\n"); + + response.append("\r\n"); + + out.write(response.toString().getBytes()); + } + + /** + * + * @param in + * @return + * @throws IOException + */ + private HttpRequest readRequest(InputStream in) throws IOException { + StringBuilder sb = new StringBuilder(); + byte [] buffer = new byte[4096]; + int bytes; + + byte endSequence[] = new byte[] {13,10,13,10}; + + while ( (bytes=in.read(buffer)) > 0) { + sb.append(new String(buffer, 0, bytes)); + + if (bytes > endSequence.length) { + boolean foundSequence = true; + for (int i=0;i(listener)); + } + + public void removeClientConnectionListener(ClientListener listener) { + clientConnectionListeners.remove(listener); + } + + /** + * + */ + private void fireClientStopsStreaming() { + Iterator> iterator = clientConnectionListeners.iterator(); + while (iterator.hasNext()) { + WeakReference ref = iterator.next(); + + if (null == ref.get()) { + iterator.remove(); + } else { + ref.get().clientStopsStreaming(); + } + } + } + + /** + * + */ + private void fireClientStartsStreaming() { + Iterator> iterator = clientConnectionListeners.iterator(); + while (iterator.hasNext()) { + WeakReference ref = iterator.next(); + + if (null == ref.get()) { + iterator.remove(); + } else { + ref.get().clientStartStreaming(); + } + } + } + + /** + * Sleep for a number of milliseconds and encapsule any exception in a EncapsuledExceptionRuntimException. + * @param ms Number of milliseconds to sleep + */ + private void sleep(long ms) { + try { + Thread.sleep(ms); + } catch (InterruptedException e) { + throw new EncapsuledExceptionRuntimException(e); + } + } +} diff --git a/src/main/java/se/slackers/locality/shout/ShoutServer.java b/src/main/java/se/slackers/locality/shout/ShoutServer.java new file mode 100644 index 0000000..5853063 --- /dev/null +++ b/src/main/java/se/slackers/locality/shout/ShoutServer.java @@ -0,0 +1,90 @@ +package se.slackers.locality.shout; + +import java.io.IOException; +import java.net.ServerSocket; +import java.net.Socket; + +import org.apache.log4j.Logger; + +import se.slackers.locality.shout.manager.ShoutRequestManager; + +/** + * + * @author bysse + * + */ +public class ShoutServer implements Runnable { + private static Logger log = Logger.getLogger(ShoutServer.class); + private ServerSocket serverSocket; + private ShoutThreadPool threadPool; + private ShoutRequestManager requestManager; + + protected int serverPort = 8001; + protected boolean exitServer; + + public void start() { + Thread thread = new Thread(this, "SoutServer"); + thread.start(); + } + + public void run() { + log.info("Server started"); + + //.. create a listening socket + try { + serverSocket = new ServerSocket(serverPort); + } catch (IOException e) { + log.error(e); + log.info("Server stopped"); + return; + } + + //.. create the threads + threadPool = new ShoutThreadPool(5, "ShoutThread-"); + + //.. main loop + setExitServer(false); + while (!isExitServer()) { + try { + Socket clientSocket = serverSocket.accept(); + + ShoutRunnable client = new ShoutRunnable(requestManager, clientSocket); + threadPool.startShoutRunnable(client); + } catch (IOException e) { + e.printStackTrace(); + log.error(e); + + sleep(1000); + } + } + + threadPool.shutdown(); + + setExitServer(true); + log.info("Server stopped"); + } + + private void sleep(long ms) { + try { + Thread.sleep(ms); + } catch (InterruptedException e) { + log.error(e); + } + } + + public void setServerPort(int serverPort) { + this.serverPort = serverPort; + } + + public synchronized boolean isExitServer() { + return exitServer; + } + + public synchronized void setExitServer(boolean exitServer) { + this.exitServer = exitServer; + } + + public void setRequestManager(ShoutRequestManager requestManager) { + this.requestManager = requestManager; + } +} diff --git a/src/main/java/se/slackers/locality/shout/ShoutThread.java b/src/main/java/se/slackers/locality/shout/ShoutThread.java new file mode 100644 index 0000000..e7895ad --- /dev/null +++ b/src/main/java/se/slackers/locality/shout/ShoutThread.java @@ -0,0 +1,87 @@ +package se.slackers.locality.shout; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.log4j.Logger; + +public class ShoutThread extends Thread implements Runnable { + private static Logger log = Logger.getLogger(ShoutThread.class); + + private Object targetLock = new Object(); + + protected List listeners = new ArrayList(); + protected ShoutRunnable target = null; + protected boolean exit = false; + + public ShoutThread(String name) { + super(name); + } + + public void run() { + log.debug("Thread "+this.getName()+" is started"); + + while (!isExit()) { + synchronized (targetLock) { + try { + log.debug(this.getName()+": Waiting for task"); + targetLock.wait(); + } catch (InterruptedException e) { + log.error("Error when waiting for lock"); + log.error(e); + continue; + } + } + + assert target != null : "The ShoutRunnable is null for thread "+this.getName(); + + try { + log.debug(this.getName()+": Running task"); + target.run(); + } catch(Exception e) { + log.error("Thread "+this.getName()+" was aborted due to an exception", e); + } + + synchronized(targetLock) { + target = null; + } + + log.debug(this.getName()+": Task complete, notifying listeners"); + notifyListeners(); + } + + log.debug("Thread "+this.getName()+" is stopped"); + } + + public void addShoutThreadListener(ShoutThreadListener listener) { + listeners.add(listener); + } + + private void notifyListeners() { + for (ShoutThreadListener listener : listeners) { + listener.shoutThreadComplete(this); + } + } + + public synchronized boolean isExit() { + return exit; + } + + public synchronized void setExit(boolean exit) { + this.exit = exit; + + synchronized(targetLock) { + if (target != null) { + target.setExit(exit); + } + } + } + + public void setTarget(ShoutRunnable target) { + synchronized(targetLock) { + this.target = target; + targetLock.notifyAll(); + } + } + +} diff --git a/src/main/java/se/slackers/locality/shout/ShoutThreadListener.java b/src/main/java/se/slackers/locality/shout/ShoutThreadListener.java new file mode 100644 index 0000000..0be8c23 --- /dev/null +++ b/src/main/java/se/slackers/locality/shout/ShoutThreadListener.java @@ -0,0 +1,5 @@ +package se.slackers.locality.shout; + +public interface ShoutThreadListener { + public void shoutThreadComplete(ShoutThread thread); +} diff --git a/src/main/java/se/slackers/locality/shout/ShoutThreadPool.java b/src/main/java/se/slackers/locality/shout/ShoutThreadPool.java new file mode 100644 index 0000000..35666e7 --- /dev/null +++ b/src/main/java/se/slackers/locality/shout/ShoutThreadPool.java @@ -0,0 +1,57 @@ +package se.slackers.locality.shout; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.log4j.Logger; + +public class ShoutThreadPool implements ShoutThreadListener { + private static Logger log = Logger.getLogger(ShoutThreadPool.class); + + private List available = new ArrayList(); + + private List running = new ArrayList(); + + public ShoutThreadPool(int size, String prefix) { + log.debug("Starting threads"); + for (int i = 0; i < size; i++) { + ShoutThread thread = new ShoutThread(prefix + i); + thread.addShoutThreadListener(this); + thread.start(); + available.add(thread); + } + } + + public synchronized void shutdown() { + for (ShoutThread thread : available) { + thread.setExit(true); + thread.interrupt(); + } + + for (ShoutThread thread : running) { + thread.setExit(true); + thread.interrupt(); + } + } + + public synchronized void shoutThreadComplete(ShoutThread thread) { + log.debug("Recycling thread "+thread.getName()); + running.remove(thread); + available.add(thread); + } + + public synchronized void startShoutRunnable(ShoutRunnable runnable) { + if (available.isEmpty()) { + throw new RuntimeException("No available threads in pool"); + } + + ShoutThread thread = available.remove(0); + running.add(thread); + + log.debug("Using thread "+thread.getName()+" for execution"); + + thread.setExit(false); + thread.setTarget(runnable); + } + +} diff --git a/src/main/java/se/slackers/locality/shout/manager/ShoutRequestManager.java b/src/main/java/se/slackers/locality/shout/manager/ShoutRequestManager.java new file mode 100644 index 0000000..276836a --- /dev/null +++ b/src/main/java/se/slackers/locality/shout/manager/ShoutRequestManager.java @@ -0,0 +1,24 @@ +package se.slackers.locality.shout.manager; + +import se.slackers.locality.media.queue.MediaQueue; +import se.slackers.locality.net.HttpRequest; + +/** + * + * @author bysse + * + */ +public interface ShoutRequestManager { + /** + * Returns a MediaQueue object for the request or throws an exception. + * @param request + * @return + */ + public MediaQueue processRequest(HttpRequest request) throws SecurityException; + + /** + * Registers a new MediaQueue. + * @param mediaQueue + */ + public void registerQueue(MediaQueue mediaQueue); +} diff --git a/src/main/java/se/slackers/locality/shout/manager/ShoutRequestManagerImpl.java b/src/main/java/se/slackers/locality/shout/manager/ShoutRequestManagerImpl.java new file mode 100644 index 0000000..8258bc0 --- /dev/null +++ b/src/main/java/se/slackers/locality/shout/manager/ShoutRequestManagerImpl.java @@ -0,0 +1,52 @@ +package se.slackers.locality.shout.manager; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.log4j.Logger; + +import se.slackers.locality.exception.IllegalRequestException; +import se.slackers.locality.media.queue.MediaQueue; +import se.slackers.locality.net.HttpRequest; + +/** + * Handles the mapping between a request and a MediaQueue. + * @author bysse + * + */ +public class ShoutRequestManagerImpl implements ShoutRequestManager { + private static final Logger log = Logger + .getLogger(ShoutRequestManagerImpl.class); + + private Map mountpoints = new HashMap(); + + /** + * {@inheritDoc} + */ + public MediaQueue processRequest(HttpRequest request) + throws SecurityException { + try { + String path = request.getRequestPath(); + if (mountpoints.containsKey(path)) { + return mountpoints.get(path); + } + } catch (IllegalRequestException e) { + log.error("IllegalRequest ["+request+"]"); + } + + throw new SecurityException("The media queue "+request+" could not be found"); + } + + /** + * {@inheritDoc} + */ + public void registerQueue(MediaQueue mediaQueue) { + String mountPoint = mediaQueue.getMountPoint(); + + if (mountpoints.containsKey(mountPoint)) { + mountpoints.remove(mountPoint); + } + + mountpoints.put(mountPoint, mediaQueue); + } +} diff --git a/src/main/java/se/slackers/locality/util/OneShot.java b/src/main/java/se/slackers/locality/util/OneShot.java new file mode 100644 index 0000000..dc34328 --- /dev/null +++ b/src/main/java/se/slackers/locality/util/OneShot.java @@ -0,0 +1,16 @@ +package se.slackers.locality.util; + +import java.util.HashMap; +import java.util.Map; + +public class OneShot { + private static Map map = new HashMap(); + + public static boolean test(String id) { + if (map.containsKey(id)) { + return false; + } + map.put(id, Boolean.TRUE); + return true; + } +} diff --git a/src/main/resources/application-context/data.xml b/src/main/resources/application-context/data.xml new file mode 100755 index 0000000..fd4249f --- /dev/null +++ b/src/main/resources/application-context/data.xml @@ -0,0 +1,89 @@ + + + + + + + + + + + + + + + + + + se.slackers.locality.model.MetaTag + se.slackers.locality.model.Tag + + + + + se.slackers.locality.model + + + + + + ${db.hibernate.dialect} + + 20 + true + create + 2 + + org.hibernate.cache.NoCacheProvider + + true + true + true + + false + + + + + + + + + + + + + + + + + + + + diff --git a/src/main/resources/application-context/main.xml b/src/main/resources/application-context/main.xml new file mode 100755 index 0000000..3fb4fb9 --- /dev/null +++ b/src/main/resources/application-context/main.xml @@ -0,0 +1,13 @@ + + + + + + + + \ No newline at end of file diff --git a/src/main/resources/application-context/shout.xml b/src/main/resources/application-context/shout.xml new file mode 100644 index 0000000..9d4de7e --- /dev/null +++ b/src/main/resources/application-context/shout.xml @@ -0,0 +1,14 @@ + + + + + + + + \ No newline at end of file diff --git a/src/main/resources/conf.properties b/src/main/resources/conf.properties new file mode 100755 index 0000000..199e656 --- /dev/null +++ b/src/main/resources/conf.properties @@ -0,0 +1,5 @@ +db.driverClassName=org.h2.Driver +db.url=jdbc:h2:db/locality.db +db.username=sa +db.password= +db.hibernate.dialect=org.hibernate.dialect.H2Dialect \ No newline at end of file diff --git a/src/main/resources/log4j.properties b/src/main/resources/log4j.properties new file mode 100755 index 0000000..db34227 --- /dev/null +++ b/src/main/resources/log4j.properties @@ -0,0 +1,16 @@ +log4j.rootCategory=DEBUG, CONSOLE, LOGFILE + +log4j.category.org.apache.commons=ERROR + +log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender +log4j.appender.CONSOLE.Threshold=DEBUG +log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout +log4j.appender.CONSOLE.layout.ConversionPattern=%d{ddMM HH:mm} %-5p [%t] %c %x - %m%n + +# LOGFILE is set to be a File appender using a PatternLayout. +log4j.appender.LOGFILE=org.apache.log4j.FileAppender +log4j.appender.LOGFILE.File=logs/locality.log +log4j.appender.LOGFILE.Append=true +log4j.appender.LOGFILE.Threshold=DEBUG +log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout +log4j.appender.LOGFILE.layout.ConversionPattern=%d{ddMMyyyy HH:mm:ss,SSS} %-5p [%t] %c %x - %m%n \ No newline at end of file diff --git a/src/main/resources/schemas/locality.xsd b/src/main/resources/schemas/locality.xsd new file mode 100755 index 0000000..fe514c3 --- /dev/null +++ b/src/main/resources/schemas/locality.xsd @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/test/java/se/slackers/locality/dao/MetaTagDaoTest.java b/src/test/java/se/slackers/locality/dao/MetaTagDaoTest.java new file mode 100755 index 0000000..e90c302 --- /dev/null +++ b/src/test/java/se/slackers/locality/dao/MetaTagDaoTest.java @@ -0,0 +1,47 @@ +package se.slackers.locality.dao; + +import org.hibernate.SessionFactory; +import org.springframework.dao.DataRetrievalFailureException; +import org.springframework.test.AbstractTransactionalDataSourceSpringContextTests; + +import se.slackers.locality.model.MetaTag; + +public class MetaTagDaoTest extends AbstractTransactionalDataSourceSpringContextTests { + + protected MetaTagDao tagDao; + protected SessionFactory sessionFactory = null; + + public void testSave() { + MetaTag tag = new MetaTag(); + tag.setName("testMetaTag"); + tagDao.save(tag); + + MetaTag fetchedMetaTag = tagDao.get("testMetaTag"); + assertEquals(tag.getId(), fetchedMetaTag.getId()); + } + + public void testDelete() { + MetaTag tag = new MetaTag(); + tag.setName("testMetaTag"); + tagDao.save(tag); + + tagDao.delete(tag); + try { + tagDao.get("testMetaTag"); + fail(); + } catch (DataRetrievalFailureException e) { + } + } + + protected String[] getConfigLocations() { + return new String[] { "application-context/main.xml", "application-context/data.xml" }; + } + + public void setMetaTagDao(MetaTagDao tagDao) { + this.tagDao = tagDao; + } + + public void setSessionFactory(SessionFactory sessionFactory) { + this.sessionFactory = sessionFactory; + } +} \ No newline at end of file diff --git a/src/test/java/se/slackers/locality/dao/TagDaoTest.java b/src/test/java/se/slackers/locality/dao/TagDaoTest.java new file mode 100755 index 0000000..1065079 --- /dev/null +++ b/src/test/java/se/slackers/locality/dao/TagDaoTest.java @@ -0,0 +1,47 @@ +package se.slackers.locality.dao; + +import org.hibernate.SessionFactory; +import org.springframework.dao.DataRetrievalFailureException; +import org.springframework.test.AbstractTransactionalDataSourceSpringContextTests; + +import se.slackers.locality.model.Tag; + +public class TagDaoTest extends AbstractTransactionalDataSourceSpringContextTests { + + protected TagDao tagDao; + protected SessionFactory sessionFactory = null; + + public void testSave() { + Tag tag = new Tag(); + tag.setName("testTag"); + tagDao.save(tag); + + Tag fetchedTag = tagDao.get("testTag"); + assertEquals(tag.getId(), fetchedTag.getId()); + } + + public void testDelete() { + Tag tag = new Tag(); + tag.setName("testMetaTag"); + tagDao.save(tag); + + tagDao.delete(tag); + try { + tagDao.get("testMetaTag"); + fail(); + } catch (DataRetrievalFailureException e) { + } + } + + protected String[] getConfigLocations() { + return new String[] { "application-context/main.xml", "application-context/data.xml" }; + } + + public void setTagDao(TagDao tagDao) { + this.tagDao = tagDao; + } + + public void setSessionFactory(SessionFactory sessionFactory) { + this.sessionFactory = sessionFactory; + } +} diff --git a/src/test/java/se/slackers/locality/dao/TagTest.java b/src/test/java/se/slackers/locality/dao/TagTest.java new file mode 100755 index 0000000..410c79d --- /dev/null +++ b/src/test/java/se/slackers/locality/dao/TagTest.java @@ -0,0 +1,45 @@ +package se.slackers.locality.dao; + +import org.hibernate.SessionFactory; +import org.springframework.test.AbstractTransactionalDataSourceSpringContextTests; + +import se.slackers.locality.model.MetaTag; +import se.slackers.locality.model.Tag; + +public class TagTest extends AbstractTransactionalDataSourceSpringContextTests { + + protected TagDao tagDao; + protected MetaTagDao metaTagDao; + protected SessionFactory sessionFactory = null; + + public void testManyToMany() { + Tag tag = new Tag(); + MetaTag metatag = new MetaTag(); + + tag.setName("tag"); + metatag.setName("metatag"); + metatag.addTag(tag); + + tagDao.save(tag); + metaTagDao.save(metatag); + + System.out.println(tagDao.get(tag.getId())); + System.out.println(metaTagDao.get(metatag.getId())); + } + + protected String[] getConfigLocations() { + return new String[] { "application-context/main.xml", "application-context/data.xml" }; + } + + public void setTagDao(TagDao tagDao) { + this.tagDao = tagDao; + } + + public void setMetaTagDao(MetaTagDao metaTagDao) { + this.metaTagDao = metaTagDao; + } + + public void setSessionFactory(SessionFactory sessionFactory) { + this.sessionFactory = sessionFactory; + } +} \ No newline at end of file diff --git a/src/test/java/se/slackers/locality/data/CircularBufferTest.java b/src/test/java/se/slackers/locality/data/CircularBufferTest.java new file mode 100644 index 0000000..b8124b4 --- /dev/null +++ b/src/test/java/se/slackers/locality/data/CircularBufferTest.java @@ -0,0 +1,100 @@ +package se.slackers.locality.data; + +import junit.framework.TestCase; + +import org.junit.Test; + + +public class CircularBufferTest extends TestCase { + private CircularBuffer buffer = new CircularBuffer(1000); + private byte [] temp = new byte[1000]; + + @Test + public void testReadEmpty() { + buffer.reset(); + assertEquals(0, buffer.read(temp, 0, 10)); + } + + @Test + public void testWriteRead() { + buffer.reset(); + int length = 100; + assertEquals(true, buffer.write(temp, 0, length)); + assertEquals(length, buffer.read(temp, 0, length)); + } + + @Test + public void testWriteReadOverflow() { + buffer.reset(); + int length = 100; + assertEquals(true, buffer.write(temp, 0, length)); + assertEquals(length, buffer.read(temp, 0, length*2)); + } + + @Test + public void testWriteOverEdge() { + buffer.reset(); + assertEquals(true, buffer.write(temp, 0, 900)); + assertEquals(100, buffer.read(temp, 0, 100)); + // should be 200 bytes free in buffer + assertEquals(true, buffer.write(temp, 0, 150)); + } + + @Test + public void testWriteOverEdgeLimit() { + buffer.reset(); + assertEquals(true, buffer.write(temp, 0, 900)); + assertEquals(100, buffer.read(temp, 0, 100)); + // should be 200 bytes free in buffer + assertEquals(false, buffer.write(temp, 0, 250)); + } + + @Test + public void testReadOverEdge() { + buffer.reset(); + assertEquals(true, buffer.write(temp, 0, 900)); + assertEquals(800, buffer.read(temp, 0, 800)); + // readIndex = 800, writeIndex = 900 + assertEquals(true, buffer.write(temp, 0, 500)); + assertEquals(500, buffer.read(temp, 0, 500)); + } + + @Test + public void testReadOverEdgeLimit() { + buffer.reset(); + assertEquals(true, buffer.write(temp, 0, 900)); + assertEquals(800, buffer.read(temp, 0, 800)); + // readIndex = 800, writeIndex = 900 + assertEquals(true, buffer.write(temp, 0, 500)); + assertEquals(600, buffer.read(temp, 0, 700)); + } + + @Test + public void testRandomness() { + buffer.reset(); + int size = 0; + + for (int i=0;i<100;i++) { + size = 1000; + while (true) { + int len = (int)(Math.random()*400.0+100.0); + if (!buffer.write(temp, 0, len)) + break; + size -= len; + } + + assertTrue(size >= 0); + + size = 1000-size; + while (true) { + int len = (int)(Math.random()*400.0+100.0); + int bytes = buffer.read(temp, 0, len); + size -= bytes; + if (0 == bytes) + break; + } + + assertTrue(size == 0); + } + } +} diff --git a/src/test/java/se/slackers/locality/data/ExpandOnWriteCircularBufferTest.java b/src/test/java/se/slackers/locality/data/ExpandOnWriteCircularBufferTest.java new file mode 100644 index 0000000..e80faf9 --- /dev/null +++ b/src/test/java/se/slackers/locality/data/ExpandOnWriteCircularBufferTest.java @@ -0,0 +1,45 @@ +package se.slackers.locality.data; + +import junit.framework.TestCase; + +import org.junit.Test; + + +public class ExpandOnWriteCircularBufferTest extends TestCase { + private static final int SIZE = 1000; + private ExpandOnWriteCircularBuffer buffer = new ExpandOnWriteCircularBuffer(SIZE); + private byte [] temp = new byte[SIZE]; + + @Test + public void testReadEmpty() { + buffer.reset(); + assertEquals(0, buffer.read(0, temp, 0, 10)); + } + + @Test + public void testWriteRead() { + buffer.reset(); + int length = 100; + assertEquals(true, buffer.write(temp, 0, length)); + assertEquals(length, buffer.read(0, temp, 0, length)); + } + + @Test + public void testRandomness() { + buffer.reset(); + int size = 0; + + for (int i=0;i<100;i++) { + size = 0; + for (int j=0;j<10;j++) { + int len = (int)(Math.random()*400.0+100.0); + buffer.write(temp, 0, len); + size += len; + } + + assertTrue(size-SIZE+1 == buffer.getReadOffset()); + + buffer.reset(); + } + } +} diff --git a/src/test/java/se/slackers/locality/data/FixedFrameSizeFrameStorageTest.java b/src/test/java/se/slackers/locality/data/FixedFrameSizeFrameStorageTest.java new file mode 100644 index 0000000..97687a7 --- /dev/null +++ b/src/test/java/se/slackers/locality/data/FixedFrameSizeFrameStorageTest.java @@ -0,0 +1,48 @@ +package se.slackers.locality.data; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; + +import org.junit.Test; + +import se.slackers.locality.media.Frame; + + +public class FixedFrameSizeFrameStorageTest { + + @Test + public void testInsertUpdate() { + FixedFrameSizeFrameStorage storage = new FixedFrameSizeFrameStorage(); + + // fill the storage with entries + long time = 0; + for (int i=0;i<100;i++) { + storage.add(makeEntry(time)); + time += 26; + } + + FrameStorageEntry entry = storage.find(6*26+3); + String value = new String(entry.getFrame().getData()); + assertEquals("10011100", value); + + storage.purgeUntil(10*26); + try { + storage.find(10*26-1); + fail(); + } catch (RuntimeException e) { + + } + } + + private FrameStorageEntry makeEntry(long time) { + byte [] data = Long.toBinaryString(time).getBytes(); + + Frame frame = new Frame(data.length); + frame.setLength(26); + + System.arraycopy(data, 0, frame.getData(), 0, data.length); + frame.setSize(data.length); + + return new FrameStorageEntry(time, frame); + } +} diff --git a/src/test/java/se/slackers/locality/data/MetadataManagerTest.java b/src/test/java/se/slackers/locality/data/MetadataManagerTest.java new file mode 100644 index 0000000..e9c0403 --- /dev/null +++ b/src/test/java/se/slackers/locality/data/MetadataManagerTest.java @@ -0,0 +1,21 @@ +package se.slackers.locality.data; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +import se.slackers.locality.model.Metadata; + + +public class MetadataManagerTest { + private MetadataManager mm = new MetadataManager(); + + + @Test + public void testParse() { + Metadata info = Metadata.create("ARTIST", "ALBUM", "TITLE"); + + String result = mm.parseFormat("${artist} $album$track ?(title,-) ${title}", info); + assertEquals("ARTIST ALBUM - TITLE", result); + } +} diff --git a/src/test/java/se/slackers/locality/media/reader/mp3/Mp3MediaReaderTest.java b/src/test/java/se/slackers/locality/media/reader/mp3/Mp3MediaReaderTest.java new file mode 100644 index 0000000..e2b1fbe --- /dev/null +++ b/src/test/java/se/slackers/locality/media/reader/mp3/Mp3MediaReaderTest.java @@ -0,0 +1,41 @@ +package se.slackers.locality.media.reader.mp3; + +import java.io.File; +import java.io.IOException; + +import junit.framework.TestCase; + +import org.junit.Before; +import org.junit.Test; + +import se.slackers.locality.media.Frame; +import se.slackers.locality.model.Media; + +public class Mp3MediaReaderTest extends TestCase { + + private static final File base = new File("target/test-classes"); + private Media media = null; + private Mp3MediaReader reader = null; + + @Before + public void setUp() { + media = new Media(); + media.setMediaFile(new File(base, "test.mp3")); + + reader = new Mp3MediaReader(); + } + + @Test + public void testRead() { + try { + reader.open(media); + Frame frame = new Frame(4096); + + reader.readFrame(frame); + reader.readFrame(frame); + } catch (IOException e) { + e.printStackTrace(); + fail(); + } + } +} diff --git a/src/test/java/se/slackers/locality/net/HttpRequestTest.java b/src/test/java/se/slackers/locality/net/HttpRequestTest.java new file mode 100644 index 0000000..b5a378e --- /dev/null +++ b/src/test/java/se/slackers/locality/net/HttpRequestTest.java @@ -0,0 +1,19 @@ +package se.slackers.locality.net; +import junit.framework.TestCase; + +import org.junit.Test; + +import se.slackers.locality.net.HttpRequest; + + + +public class HttpRequestTest extends TestCase { + + @Test + public void testRequest() throws Exception { + String httpRequest = "GET /media.mp3 HTTP/1.0\n\rHost: localhost\n\rUser-Agent: xmms/1.2.10\n\rIcy-MetaData:1\n\r\n\r"; + HttpRequest request = new HttpRequest(httpRequest); + assertEquals("/media.mp3", request.getRequestPath()); + } + +} diff --git a/src/test/java/se/slackers/locality/shout/ShoutServerTest.java b/src/test/java/se/slackers/locality/shout/ShoutServerTest.java new file mode 100644 index 0000000..46da7e9 --- /dev/null +++ b/src/test/java/se/slackers/locality/shout/ShoutServerTest.java @@ -0,0 +1,51 @@ +package se.slackers.locality.shout; + +import java.io.File; + +import junit.framework.TestCase; + +import org.junit.Test; + +import se.slackers.locality.data.FixedFrameSizeFrameStorage; +import se.slackers.locality.media.queue.MediaQueue; +import se.slackers.locality.media.queue.MediaQueueImpl; +import se.slackers.locality.media.queue.MediaQueueProcessor; +import se.slackers.locality.media.queue.PreloadDataMediaQueueProcessor; +import se.slackers.locality.media.reader.MediaReaderFactory; +import se.slackers.locality.media.reader.mp3.Mp3MediaReader; +import se.slackers.locality.model.Media; +import se.slackers.locality.shout.manager.ShoutRequestManager; +import se.slackers.locality.shout.manager.ShoutRequestManagerImpl; + + +public class ShoutServerTest extends TestCase { + + @Test + public void testServerStart() { + Media media = new Media(); + media.setMediaFile(new File("test.mp3")); + + MediaReaderFactory mediaReaderFactory = new MediaReaderFactory(); + mediaReaderFactory.addMediaReader(new Mp3MediaReader()); + + MediaQueue queue = new MediaQueueImpl("mediaQueue"); + queue.setMountPoint("/media.mp3"); + queue.add(media); + + MediaQueueProcessor processor = new PreloadDataMediaQueueProcessor(); + processor.setMediaQueue(queue); + processor.setMediaReaderFactory(mediaReaderFactory); + + queue.setMediaQueueProcessor(processor); + queue.setFrameStorage( new FixedFrameSizeFrameStorage() ); + + ShoutRequestManager manager = new ShoutRequestManagerImpl(); + manager.registerQueue(queue); + + ShoutServer server = new ShoutServer(); + server.setServerPort(8001); + + server.setRequestManager(manager); + server.run(); + } +} diff --git a/src/test/resources/silence.mp3 b/src/test/resources/silence.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..65056b9d0af28c810e0998717d32e5695d5f6a0f GIT binary patch literal 338 scmezWN#KaIIs*d(^B*9=;N$4)YOH5z4rKlxl_3xYdhVcb^FRwX0FDhz{r~^~ literal 0 HcmV?d00001 diff --git a/src/test/resources/test.mp3 b/src/test/resources/test.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..4f603009362440526001dc1f498ac9b3bc91f3bd GIT binary patch literal 396241 zcmbrmWmp_hx-DEl)Y;O_1c96|^ZBzPbM5AN;|yl*q-+&eSR z%$%9?ef6W+y&rZ}_p0@-SN2;CzQ+J%n*r!&01yxe00_WehEMi^>bz83>M5&vazK-hm@rvQM0chq0KE066t{3sZ}@$eZ9*g!KKMpN5^ z34Hlin8%Gw=rAwtXAC7aY1_K{61&(;MsQ}1goG~`#kp`+k_EgAbNh#54nfl2x3Co| zlAy4PXwBs>S8?Zzo76gBV191DsJ;d-N0x-8K1+3ncMpIKfr-B1AxJUMl~1k4P^R;4&jd0ey{Na|_t!+@eNTN=QV0rD zPxLwYVeA`?V=ohD1={88AIO{UEL zdHq|Ax+|EcuQM$Po?0G*ASWrm|Pi!&RDSx($t4$J%pMGS_wWEZ z?=)GR_&x#T!w+FZ4E}->TMrUz(F02j3Y6;5&v6pxw5X z{ul*gWwwZ?-94-xV$#DgBdY(%vBKFOP@C$M#emC9|EdhG4g?TrC6SlA$q=E%0BE95 zxYijmP>YdEbQHV(v!Fq~rj#*MMAssFN6WX{e<-EcQdtrsW_78CFI_}aUSog|;@(t^ zZW%@5O5CHm*?J(={gNt>f~DoK84S9jJvRy1ks`^b8;!|iWE)OJFKmo|0x>C1ipR!G zD?~_l2h>6?2^%Q>)+8*bM-BkCxoE3V(|cSw`DASqe~>m+rRQGnG)ETJ7bRlv6KAI{ zMPb9-U6EREbNI8t6Zk<{hS78jNPl;9!J_bo*C!DOll&vq6NxMo)y^!7bUV>~Nr|SK zy!~CtKZVW%#PX^s8w4$I5IL4^*vO z%g6#nN}VV+&pb&w+Hvz!jo8^v8~uEaD`lZ|@7M31tE5-e+YEje*(YC(*JYA5kryx3 z%bBvnC!Q{OAvU{)D-osej8OhQ2q($&8sN05O(3dzCyz0t$gW?>W>H*`lO;es(^M(* z+*H$LwU_1HdttQSR$}bTb7<%wHKY2A!8`H#r`_=xH3p6>lJ@TNaA2dB;@O#38d+H( z2U>xpif!-Dj*ixNXIrT1NEau6w+UsJYgJ{jZ)lRC_ILP|;Wjfu@l(&;25y~kKlp)k zXU)Li0<~UF@EjYAd2`|!-z$uhixVl|3WU%pH=4I6$Hg2sFjZ5{--zxbI8WG)D}L;; z@UwTZIcvgsYYyM|rqv!Es6S!&q?hWK|E>Ii?_EG?5N(8Z5?S^d6FU$nJ**YB5{0iA zcHb?PE||jk6i24ez4EtrFR8HaL6w&P=&Dsp@BF-ifI0Ve5~h z4$oDKy3|(7t>a#I`9w;*71`Zp$0AZbwYn^d#!ZIq8m-PoZ!p9t`jth02f_%M$T%+6 z_KxQibk(^St^aA&D~i(^=>Cef^4TV`W5u&e=SU;*>b9*SzT%YaDZ_y#LaaxO8fENs zp#X0Bfr_~wl&j;MIH6r!XiKGkA?q2rdxerEPYKtyU^pJYbXnE4WXG!kc9y+}@eZ%0 zZZ`$65U`TjhK!crH|`8j|Ptj%Yzzrn*NT2`$rT$&0mHRD=dvR$y7b^Lgh(+mJ?aEQKY z0RPZC9IUUODdgc;%=m3i_=1_3sF-D2Ke;Yoy9X4VK00oDD0~oub|+@&`{)?h$0}H5 zb`y%be@!+rdNxVC+=o#ProMXyV2k~MT(z@HyaJvFqs}*0G|e7uQBpzqlk08wBjEqHzrPP z=uuzS0I&T>bOXzxl&^zj^j8cjc_m*9A-L7;t+Iq)xB%wXcRf&Iwg(_HxXIu6!}B@( z-}12!T9-s00Ekt zTkjB6h@QXn&{$YH0xl=hp@wazUANH*ZeNk8Mw?*D7J$UplYEANkJY_jGGc1^^YP)V)j& zV%AwC`K}*rq|=aM>F}h&bM#|?pGhQSz1)oW**<2>I^LTPfIPT&vaMResw5QoD85Vr?~fuw7p(iXWVV-TJV{tWScO|g{#T{=USwh_Y zFfDmmQD!;`#CiOW#|v;msQ?00GOOYKA-^pX^=K{ih8+^ZoI?%$&q@>saF=OH06>pP z+z|-8OHEwRNeD_XZ{*=?>ITNuzY;alkp=*ccJ%1}q&_}zT^ISz-9N4aGIPHL2 z03Hz|=NJ4)NnYNYgP=4sKaUO&%{_3G0`*Y$^dX;kqh3)Z8pdqGLri3pXGX}hia}B# ztK`=%ulelekEiTr!o**EV)zFH&AIW|`K!Nb(PZR_^4j0oR8lcbavC?dqQ@6gJub6_ zbAiakqQzl0!NZpsLKr}h4B1T&pq7v^!W*1RsX+WAJ8gDU<5d%*yOIk-b|~y4!p0V# zb9;*44*&GkyA_7&_}k+h*b!5S4M2$uJ!7tr9hMts?DN*rzsByxUIj8k(R7W)ojsvyGaSU~vWn2d~uidSxJL!&=yYxfuj=@&*@ z34L#wGm=5ZK-Ieq7R|VXvQD43r)Xq48`hr~KH*8}De71K2#QqSi;z6T_Ne8GTj=U; zbWlKmBB7LiKIp+P`(ABZRcrNu+KG$1VPad{c%x0Gu~ldV&Z;aNcfnTf7=Prwr8`nn zf<5P})5UzKJ?K+44@-TI*eNlm`GH0nh<@0NJ*b3~$(4XZER9e2h_7{ClYE zHac~j>1ow71h1nrv`d^wPb!UqXMIE9c7B{95C+ico(71a^Lv@d8KdnH!uBj{yVKQ~9by@65GMfnpzJCuGD6Ce47Rz!&3-l&%kL$DD*npc-c!;ubUBaT&6S2$Aj zFF__6{^ofg`Hm>2Wo_27FFWs0s?N%1zN}N=e+Y*D1!Dg_{Q}%bAq2QH)+Z=yNoUJ};&EJENtU&hT2b=gCG6n#|#xw;$!=S@AjZ@BYBQ9~a5@N^u zisDru3bLsmyGD~{14-`VVgZ9$_#U)tg4*Zw03d#<2XGahsz^4&D)j!wQEwuJ(?9SEKJy)y0C zLlIW+snqE%O3JAd8J1F;VkDM60Eb08-0HP<=_0oq`=3h$BBo;0{}lyafUER^ggsbP zdNXFG2%?gT0yWG~2x|k&dY9mDB*`62Y~8m22!Uk_fYrs*rCWqHV!VY@6sFf9^nbRy zvZ5L~B15_1bWE-JK|nBOLUnjL@%d+r@7=9-(y6=8rDK#>fBTgw_2+V_y^? zmO#a2>-^-sFX{01SvWz?uargwQ4!=Nfr-b#Y+20M3BG!7@-%#mzgg7ZiW2ypgd=3w$3 zB)PEP%Uc9c3N47fSIGbaV$$3938t|0@A%TJ?08qt;0lZty56GGmSm(%RarQ0CSu-yd)J3sl34~|cCUgV$JzQ$VU z6l;46MOvDiPMNxh^i-_7W2+U4g)(dob`sN~bcHE&nLzZ@X@JJy6*^_X5zSZCggSYLmA2bE8bFyGN2aCr&P|G^TZ?u2U+dV^04X zpd(Jp3I<>(v|Ri7!+SX^*@~ir`Q5(w#m!)=i_$u_neLBoYMz3>|C;kl_hTXWq|m5_ zPCtjt>n-qoJ7##Di{W2-Fz|f=DEK?1aBwPedm>_T7BKkyG}!lyICK~C)e4~C$!GJ7 zDF6Wg7CD}}!0Aa_1SG3{Ac@wE6t{kGDNOIQ_fyI?PRHcd$K<9MxFT2@%VSN`$|lxS z#-KA7gNu~PU3MS1be9TblYUDq78=yuQ5i@3eUAl3d|FTK!cu-E`Xm@n!!ByeGHSg< zCcH--oKBSW4nu70i%Trs$E{4c)6x4W0KfnclBhcTUL!$1sJ7#{cKkY(y8af2^OuRJ zWQRtC?;q)u6$h?pcP!8S8cXIE?8+jUKK3{gs0v?7+_mq)QMRE15#hndrLP{?uJV{e}@Mx^kN-zS>aB_%N6t;y@iN&qRvr#=1l*-uZ zaSD`pu{YG%(-=+N61gD-wXll2b;<|ZFahmwXyz3!L}XcGMIKlB9QVno74I&=6P}05 zdFD2*?!2rl+xZi(aK2rw*X8i}wB+QPoVpKI(0dyGQ1kzFwp>Ml9PcItQ7$6+Qaw}r zoy#6M1AznmrYNb+yzsQk@$*&Jw$;3ER_&#aSJS^_2HpGF2L%c}_=N7b`f;W;IX07B zUhMAw-|?bXW{_$Y)Uu%I9Uab|;I1PX^>#e`Qm6M;#U=S(dL5S~Lku138T+(H2T&1%`U+^wyTQaX1W+X;_|JiwFSi=U#t@Q=^s2vP&g0X z-&gRad`KV%5J6$A@23GNIUC2E8`X2MFXK;$h_H)`6*?j~p75Ua*&86&T8Tw+1@ye| zNLp~AvxZ3RI#fGZ@~^0d!a!NL-Zob;z#@|u8I|D_V5zH@8?~u&J=+cG*fhbQ%2sQQ z#0uFhEJEzwGn{rfSe6J}iXYzZpP&Bs0KWkDL-IxF1x>s^3fPLuI-*m^Cc`s#`j+I% zuWe$pa)q=S!9kO!$Z&s{6N8KHZ5pjx7$2W6zCiI};ool*Wva`-VWkqwy;F~iG?;<5 z^kdyS9Krsem7ir;kkOqIptGm_q_`CX46$fn9zS1!gn!hhT%@^AR`;A?a7k&g2z+;% zq!o&TU9EJMIRFjanoNGV2z{&!;A#_R51@apovgmmxFi1t9cI=&M-HqP-j|_&*CvlvQ1p&dlvfW8N@P##Q zX;f^LT_2JZ)lXPI==A^If(G~4`LM13GKqP&!D22ZZkH+6Psic4Gd+++U54QnYs^H% z)N^ijbn9BtNnQxGFmrl55B+^_f~ddl=0e^;qSJ3*AoF~!;}(@w)@8qLQq&zq87W;1 zgXbE?ZzZtyr!XnPd4$Mmye&w0{jsbE?k*N)gaTxFsd>8%ti3UObN7%nV@-EStF3^f z!AK&!t#s!#oJc|l9$00S5!u7aWXX9yTK@cu?_jW;d6gIPLku)@6}l9vlDiM9RTxM` zRkXUcG5LVcA@kboEGJaKob6B(nYKJwMu8IA^XEZhO>7YL%(ugCXL^-dww9k`!ilt4 zA7m_AW@_Oq){WKru=(`zTp1?Hr@(^r5}ZSPiV-_)OWxJ{dLdsLc^Yqmw^-* zgs;JAE)bz7hoxR%dbs+0)B`|U6!sN1Z#34ku%P*pm~KyC=3wp@A0EeyVQTpPg)gU(lM1B3K}WMZ)WT@IRM2sELl?3 zD3t?>G^*J6u0h@T$J6d8<8w&uCFFz;H(7L!JpA0pZ-^N*h}+!99c?^O_|BBb0rTPO zIl;G`segbkSV*a9-vB5vDeK>hAW$ZnE}w25+u9qZnd#NrDXD{Vz5C!_Kj>jp65abX zWQ!C+SvCaU6c=;rpSv!SZ?}u>?Bc)eE7*Vh=Gqb-uyqZo*#`onZ7Bc<({+9%w6gIa zlJU0P?dY=+NjjxSB)3G_v@{JrjRf8~X>?QVxMZrAskas3y@tI@avBQ`GETWdNXJlMi5OY<5d*ae>sNa@`D`iyED%4oUJJY2 z*Gqn%6CCOQF2YCFZQlBx)%?9xlfe(fdz|Gr2RN`v$jSl=fcTeBpGej9MqtAQs`1X{ z@P(UERS}TMQn(+T7lgyn@18@tsBT#|pWsBFz63*arMWwk1VZmrEaRZyizP4W@jt0L zRcSNgpwz`uEs2@C1PNG zM8k=8f3z4g1$?fFe)Vk$%N60S8CKcP#onBX7mmAjoI|2AdU3dZR z*%5$(+UHufi{u{?D$CAgf#-*RHwP(s?UFxcoe15KJOZE*+R^)FfGA5)p^WZpfOQ(t zodEOCmZ+dAk!jNSRw2DMA-J|UxDK51sE<$2VK=?Mv(*USmOkTls*V6KQXw>7hX6+Z zCQ7)?b7uuT_KTPuREu>n`_xHIqO2GpHp4v1$KI!C&HjOBu*8FT?RW)qn+6!?;DZ`~ z380j0S;h=EHGK`08#6s`THPe1l6M6X#3YXK`QxKUMNQ{MMB6Jjg2B$C$LTCxps|a# zb9s?!pnx1Y7{J=vo`gDRvVDsAAa$?>;s~9PHWY2r#@Y$=43l`k&4Gr2xT&3^DI<5yPKHa(ddb9X`U5$Vih99puA> z@4hv~VnDHsAH~4>ZUy^zAf{m-a(3v)w?j;Esv0+$O$o+gjhiiM{kWWuk zD0802b>G^%O5@|>n~94{MzS?6k%^E^0Yw77i<4-uMYV=9#Z}z<*{`q9qjpY^D}_dE zhsx_DU)#AcnC}Uaa#u=3NaMXm8pJL%sMC;0m#fKYSm9wcKD_tM&M~l@g_$M`Y)LGV z$D(f8vzj6YDk;8$6ANJJhpn>3P>WZy5gSw#mz%5~;D&(XIZIW$$JvdNQxhgJE<^7g7R&!DYZ4q-_SxL?7gX$Fry6teJ%AChH#RI@&MN!{-8i;FNo=%-^|BjM=`A$QrNntmT}e z&jQU*7GnQn@%#n2{4fYhsaf@Z!4c|-OaC?y>Qj|ntFx;iw^>I|cWQ3PS_Tjpl#fk8 zi$qPs*r|d`xSSg5o@CRs8VCvN;gp=gv}M7`hb?Z?zd#6jKSQ{Gu8&K&Xxl{{`*-r_=)uG^z1Z8jD&!mQ zZTKml^Pjq+t9WeL5a>cEG&&B!w}18kC{so5duS{}Uv69r4!dGGi;wTle~jiL$@2)& zTixL0wnk!im#lB??~_bUXeC)Y@1U5mtzDb-{HEx1_R0YeQu%JclK?fGwPaZISgw0- zUD-~n3`h05QKwxz=hT%8A?5x|>fPiXzp;mdBoXUp)BXC-hF}d|+FI>#b(_I}bB@0T zxG&~ioeW{z1~~*c@dLr_QDvb%7J0oshw_;5eKXSIcju*F0VKkwV*qZ4#I^>JII`zj zngxru)A&Zvh19Fq~%QW^Ks#dRs_G?Q&p2T|G+Hlk5?*Z!c?KcjK#VR z1o%>4t=a-aW+#*LS$X=Ox*%$@X9{d!Qs{<;iby<7GT8HG41Q8AA7>vYwQ>C|MM0p< zphVKc6-i|px#1UNCq`)HPuDVFZV80yX?h;o11cC9vFzE{iB8Y7@e&DPY*Cn3)Z#yl zB1h5{*9LKCz{)#sWhiuZ*Xzv*n52g5(OfDq5~+}|hI0^|Gs-+sn#+C>=|aG{Y}n$ajW0C%zd!3HL*_R8K!$b6JNhOkCDP) z^Hnimi*cSFd6SQ;f6`3inhzbP|ABB+;C zd5|y%JU&X9jq}N7V#_q4pZpznLxcJEZ|XBF|FXjKe?fcs`@+&eNIeB>MDVxWp8g(p zzhbOVAFSNbu~T_X?b;O{%hh>iCkP-%6ZE(W{P+r2i=SHm#D0T7`pzcjBb(4{DA%8+ zvI55@0~}Q3Y#*p&yS>HiFGGS4VFJ}5ZBAQ{KeiEv-4W^+E-uB01vL(sJ%0JNj>?DK ztl(qVxIY9ku;8SFKLaRb{ULVc>l!tUvmD?0G?`9QUwo@} zxf7+j-b4?*S%|fie)ZVbI-nU9;?uS|8Bp;=&K4hSe6x0B=J&K|aq8nI`w?ja@vP@e zYPY)L+ONU3RR~sk~5nEiazsT`~$T0PtZjUH1da@D+k*ukaj2 zjbdk8DzftvrGy)E$Dm|oNh)IBN6Kc7@|~9xID|oV9b5RF$%NG}hI`j*yHyh8JvnK> z&j5@(z^v`s%i~EfSxDXm1b+G#y zfOqN4?0U~JhCzq(s&3tFNNE3nCYoED0A=eEdi2#4hpY!Tv1D+Q2bLgJhZVwO#c5#| zW7%qn7_Ked+bblHMB<9bvRLhtD#7B7CZc>F^Xk-FS=^OMbq7lqqi>8+5X1`pi*b|? z5TG$w4fZ$r4`jj~l&S5UV()HB6qqaS<(;qI2*R2^r=Lj-7&BmXhcVFFaro>&R`#kpDLLcg# zXz31q9>j6Dv7sCR2DsHH;A1gp^QJ$Ozm{{Z`P1EkCN2|(PiS}ki0L1HWcb3@Ed_Sj zJ}24mpQ1IALZEC1r_+Z@eG1JN*uc=Fg=3^cP)ZMY45UFAYijaIwqHU zJiPKBruTp0;!6@R@KT97l~~>nmtnN5P#mWoGm)!A_ADbPH$$ah^RvWdfui7lJ>J$D zNQ?M^2Hm3BE=wt8Ap~2F`DE~++qYAPDx%B$_L<9S;0_f@tkRZeevq+Z9$KoZSQ|HN z*#GPgo_)|Cb;k!yY=vuWLWS2Y%tybJJuEgG8uky+LNQ37SuKr{{cC}}M=7zpwyD6g z*DggAafNkRmpZwsQ|mdMCWqDA>yZ=!i1Y;wOcN~++bQ<%kH4-FNB<#R`X4#S8ZaTu$=9dTAB zgMY3rSIjDjnzzB)%#C11vE@PV-fzD@N;@S)f1qI(2OpDY-Qx6jc5O%ehkWpJae|mW z7K-*;@M#a8Vx<7$2s87ZBctdPM^!fpPXpAa#uT3Ku750jch8ya7gFM~+ZjJm3ZsOl zedkTg_dLqJ>*}sx`MWlkf1?KfeS=&;gP$OqY0F$I`}B-nGBS$MLPIq0?|%7~L{=A~ zXF2ViQ(OUXSn4L=X5h1v1ojxaMt^wCfk4e}afa2C{Pp}|1RohfSI(9XdN$^VkZ%2K z`Q_K@$Jd|;pNKAY$iA2uocf)MwVGGhv8dl;o9x#EEDPnm6ZC7EHJhRb_Qk+iEr18;~=j{^yCGhUoY4wE^-@dhU=PvD)mAv@l`GVgkPCZB$ zM@grDAh0lU|9M2KLSHuOnTguj+M$t|#=huUeE^q%2dU2zQU*gxPVSV3S?MZFM zF(j-%4*hwhAH@HluKbcX0A-;tU;{a)cj)L$B$$&+6QoAy6HK&jHzXc@atb!l zxj8UV{|$;XxUJ!R8~-Ut-qlMC)GtGzFop2RMo^m&I*U1UfAI3a)kQzG_>nTX4r3)J zCe%UW&9BDlnXk=T65JeAjjz_7AB{~sf8A^Tzox@~&c7Gn4mJU(puX43cHvm_!UGQm z;$i4;9v)3I6?qGfNm&q2GE6L;E=MAXf$(GdP@09HI2Icv_|u?-4*#p zLb2cWNOk6vwk#+&>>^23&BNb^=>$QIj;;a_fJ*E!cf(}X8|nErn`@gr&aAOnedU27 zi_TP$_?@ic^i43_rs1FBB#hyUjDm$VoKwhYH=2WEsKHb#8kT3=I0uQS-30c=`@@aq}zNH@{nS*?VA7YPZ9 zZsK)@r~G7p<#5T+Ea8qF`(UEH@uL+R<%4nI)&E>J`RAa$%)S7(R1P3uPB9v(hZ9u^ zZy&}A)0n`oA&KitK_3!H@MJjZxKRdctqe z%i(wy`$}4(6*iKq`x84-ALQk{>Df8u_U#`b9lcO)4z~bxWKK0CheB>Ed*sa6pT9u* z(!On6rCN{06Q}fcR*P#BJKSKQitB6LszYfwPF;m^nYE2VB$SOwF@Ri{)GLp;FNAVOMKiiX7YV?VJdnNiZwi7j>zsEi`gF7bZ2KOV6M3KgEuT(y%&E9HuzdwO) z`A>rM7vO3&AYE%vj1Z5nB_|~HU~ERO4R;%4CEK8|HV^5v2;!iI6q*q-!94&mvaNWM zLt(rgS!MKmL&?{~v!%s{W)6uI{B?&|g+d%?c$A-Y-*))s__BT%=~V3ER#W1;y)ov7 z>Gl?=A78Z+j;0QfBDE z1JOcrJaS-3`r7eIEJ&3AKwGC@3Z2mUh&%{R*zhO|y+kS#zuEqu6O9(c{@4B;XJER@)-Oxw|q z_CpIGj038B09Z#N4JEF4tW5!eyUC&u<#)eBuPs&UXUOk&NLI8@qj~O*M!;{DK(dEX zoYc?^s~7-ApzVcDCv;!y`pC4BL9G>X-mD~aWBc0e$@JK9;Q~?2kG2G7ULm~nY-~Le z&x0PEB>}15F24#f(+J|Ia>_7>B;2JVN{f1@uyz*}A6xhxGVGsMK0MD##~yypfF
    qX+z^TwAS93b#3OUG%fq}SuC}XyrgKt#lx-GztF^dU~p`)#>05P)as8UW#~V( z%op~Ai9$eVBVEu$tHma)s_V!OtixS$tTeqTk8{G0Th-e2ncJ+Mp8cwpNi(qRTLpneAeh)J5Bh)nwC zD`}FcWpl^OnR2?=%pYU&V*J4S4l7xXmc!HAJJc(y;CVNct8NXH-1Ws*mq;=k7X=+B zbBEo?wJRgzUPzn9pc^Q*8(q|h2Mnq@sp&TlLaT9c?!Mi&xGJ7yEh|OPlA;J7xasVK z=0@W^<~o>Nx0jo8e2On%&oKqg-%os_Mqk+*7j_V>3(bFD+Vz>qU^8yxul0m~!I6JG z{gT=pXhLE?X}b3(!rf<5pp)Y<)@MXp|Lxm9;BTz)e%-IYcQ5PVRtDe0zYO4u(nKfv z2@V?u2oZ%a&)=*^5D>Uqc)#|Ru^Cgz;IN4+O!1prXh0RN^SNpk0x<|x<>rMICRH;%0-xPj`pX+|2ZNZ)FIdNrY@-$fJ zm>$=s3I?A|LVqL4Q!)h*f`ClqV#PtSb1}$SV73Oy?QCRuHh7x`9TTgat0}V$#xg{Z zvlP(W@pJ>1SxcxB48DX_AB0{R$veWYf-j%#;3_fUE%>x(Up@s$?7IhM9e52gghJ%& z-)45DtAuKK`pu5)IFqO>gmBK>6-nZsu0zg{zr5=Db~ZKQ_jvJ7gQ8(2B@u8eBs z<{<*fk`HP0+P+}b zrH?o&TDI*6@zC+ss06IY@6L7SMUWS3`GuKc?@Vn4RfF7nKzJZ~lWPEhUMV+%KoOVB zN$f4!yWh(0eKyVk(-v<(;`<*3o(*3N{EmKoSZ~+OZk{@p^xAI@P9#J@1n-YRmt_5$ znd#9|QPnXd?edM?|5XiQdUUWml?qu=NS(c7}k z0E;(iXM}XHX-PFUcUIef)f%n1Rayfg7~Y>jp~d1^RYLVV#=lDB;Om`I4!TBnvcG6~ zAKH6VmVn^tFZIhHJIQ>$bsa)Xe%7Xwi! z=EEAvG-n037yEiQv|()7{j;*B#_*j4ikdFNP=~Iv2z3*?y9)y}bZ(YmH?uyBWdMOa zmB%-x(19!|_OKauxtCsQ!}2vs-@7UWXQP5|B&(=IW4xbj^(KU$o{;Yoot@NF*vpTG z{{hz*;H0tv#9##01-m1DTk)_%MzaVe_^WOU*_w0H{q$Py&)CO>bprW>nT%xyXzV~_v=`4B--2}db8t=gCs)6q_Qjn`WPc;LW%dc8 z)1zP+-sa^G?*@*+taa5snAfkL$SQ%;Yk)!%k{VRe_?(MuNpAG@6fk3ZOsmmOVfE@3 zM$Dxw%rj(W;&|K+#r+uUrh*?o7tU`hWUUO4y%6vJr#|Q}jFUox$kQt8;{J|+o)FC; zqc8-xf(GX@f>P7tbV#<53kjMraI>FE0JkK{R36K3sfn?8u2k<`a`t{+G{t21r}_rZ z<@qAy&T}t$TysgY)<_4aYP^ZsGsy@Im2IDZ5dBbpQ>=NlOte!(9PN{hES^KgA@yN=l zd%H&-{h6VH8OQ44B&HD#zRoeZ1_o%-v4M~tNv}@HKaW~^tF|V3`%u!5reO;4?3hRL z$g`oe0OD>XoBH{rpjdsFR&%^*{j`tXr-|yo4fp=+8!xoa=DHR@VAkpE0QQ7ZHN zR72QrA=C#qJQ?u)0088$Cj4Rm=5-=>YeT;Y*l*$7rE}j~&$Uho=IJeX+at20r9RB? z;yh1`sb5t+gJaL$?4j?8e*4SH4!?Rp4n6l>j$k}08HIGs$?6S|6pnyEv?y!+Ta7 z2|}nrL{|!(5hrdyJ?L(;N9{U3qxleW;SKudhWuBs{&w^NoM9Qnyyssp?C)dQ3YCr; zo6(8FQMWskXUN+g;yZeTraD4az*Ia-0ptmUi6t{4j^BArj8s~NS3(8oUYU0*qgte- zZJweKM6z5w3E4POiDy^BiX=#@n)F{mzCQpzDpCPx5#^=Jz0vn0h6=8xXuip>3hm#W zuKUGFL#%3IdrIQfN0xncMZapIPgkr!lr?hPCy?JH1}xZ21Bl5){H1sa(n14IAjz&AdJ>@F-YTS}U?3 z=-Aj3_J&{#mDf=R|$8epfA{+gj3E>R}yd^Tq#xmj6UX`u3i+55^AAx zKLBu%2Nq%jaw$TuCL8+^ct+1Vle;Y6tCC((v~NYN5IkUH{GK1}zPrx!S=n_z_5SfQ zqIQ9e0!}fh_TLALFS@834B2-%75S}Bt5PMk?dv2=#V=2=?OuX1Lw}Bc+!BKF1OSAJ z&oO|P?4VM#B#)bCw6j?`CNWQeS}c%Qviaq~`cs~QIx$kOx~XxlRj0L6RxaMIgibZJ z?PJ%zfWiJY2mJ1L=00Hw_+zjk0ll1Ff(Hp`Y+!yztph_`*A(KeP<2k%fCA*qS>hSG z=&w>u_wm(p)QkGBC|EqZ5Z$qm5+&+~hQQ0JUni6{N5Htcz1tk{T{)2Vr#$KN;;V9q7f-TI6yw1hi@In8kD(MRCFoKKeO`9q0 zOZ}g!bliA@ma?M)qKOlqJU=R3RdhoddJ`-!1$3V@Rm8y9U8O=pOZ8)N~a>C?(RznSEIn0_$l3V zFvUu^ny`T=*Fr%f9DI3gA~{~i_zpHd2?pBqJ5E??R3IEW?|mR}fY-@oeB0C0h$X+- z+WXE+cT=0*l3%UoY%M}!Ec(lRK!#+(F}yv#yR-(=>9^FCkkD!EEUB&hz+UNB1XUx6 z^|o+BQ97Tk6%1cL57P>K@~X^xkbp0wHXbMK^n5-xfmVFNfT4L515nt6=c8N}>O*Ep z20p3TxM(RpPaRqoh+8DPYj-F^`B||R$9x@*A`D4PFonB&0ERv8HfR=f7e51Rfi&i_JOs&z)_lK8 z3JfbVPq}BEIwZNnUz(hB7Bs18Xc)nWx`k>edZrl>YCwiS$2@>AroM?w#bzBSWAO6> zxHeyMq!0VJbxy5eB!-yWD4-orXQKBNb>HB5eU(j4*be{(1M$`UBmhO_nUoCLn`-wu zZV69(ka0ZASSeH<5fIeaTc%6+x=rxON0}o&DIhlqSDz5Y!!G3wIpm8DK%TH6`*td$ z&t;@eyNKI|n^X*Lm#nImsx3qK=3DHDKjg?i| z&Uzg1lO@TeSP34ksr0Ml~hoBBeGI&r-GFfSp)@gvf=UgJ~K-|5X-v3_bwhX<*S| zIFpNMrp&14DAMxa2G}QW_B2U63nC=Zs=f)iF}4}pT4Xn42=dR08J7N3@o6~waeF4i zhNAPhmP`<1fS;ArpWRcGU301QaS-26_zQk!-dOlm5w6=vMP^1|1<5TrI$njHL?7X? z!hc@HczOE3$Qt5k^TiGA_IBnB-}N>v z)NTks1*AI82LOrv5G!s><#$JwKla1#8O#G`H$Wizgx|Eqi|lE?=}DJ5(kjM!{_3NTe;RTSZxEmQ_7Of41vR1{zD34gn z@Ey6gb=!wv?zBK{G^n>F46ajwV-R2gOmXlzmWUgxr>2~o$?kMp{W3H;>W zd(@Jx>1UZdaUO^cq%z^;r&QPeF3#0j0v<0+XXSqiI&jT(^ApT%)bnQ zoICX4_s@aIu|*kGqwI~&&L&v1P{jNPl<=iT3z(d)eKleDaoBVpiL4beheXo8UPkwp z1W$N>FIkES>a7JK#?vzBg>ukQQ$p#naLC6*$`HL%#lc-$=a-K`FF%-~Z1)@H`ta-D zY(@MN#rf;hi)gpALdsXK1Qz#0a1X2)I|Ah%8am zF$f8&U8*)N0|17Hu((zh0rFxyJd$2C9t6R(5VoH)IfO(t9E55LF#%7EX7Qrhe2$f4 z%oYcimvdlyt*mAoZ6Y>9D!m0LZ;`k_01vVJ;Q&A@&>GfjwLnxfGD|&rgZmBMOJguO z#>7-dB)`7$7giDMejVx9l6Ft+RMu>@Gq$EWCg$-uj(Yc^mLW&8>_@FR6uJZe8n|vd z>OnMZ<L+dO5g(sSey{iKIE|F-W(M$qhf-ahiDJE6ZrtzG1m<_DMWjS47-PbRCZGp zjiTvEd?#g*U*|p{hXk2l3r~={F*R;#6m4 zL9elqUXW=COOK`qi3U-I%j(e%p+4o=cU}7~)~6H`I=2)3o(k?rMk#aiTCvombonWg zsX|gN;?man^ppvC(1-x7^BI1U8*?cy6rm3e_O4|mj#-8SH*I!tCH>WQ%BSIx@T^1-eeC}o|6a=NbEOb(*Zs=CZin!e-C~qQsE=Q^xznz^z{zwniiPVEWgGIW zGn(LsKp=~~%uJRS+crpM>RtBAN*HvRcRK3*n{pUl!^+$t^JfxXu}REE@dksTgh0go z0s+V)jVK!T0H6wc$PruW=OM&=L3U(aEgtOgb3`{DC!?_x{n7mH6>*smnMR3mb~qRs zKmw&7R{*$H!_UgnrYYg2f$N+pc237*c%-sKlYK-#_uwVq6*L8_uXT4#*beL_c*?z! z46m>Q7$zj}00eRzPk%9B6wT{afeseL$Bo}Px~!(4sjtE_79I$nNax8y{3FkAM|{0swV9tLpoRWqDj%qoN4F2Ao&=2aZbBh=tqkKk)(|_37{4R9lL?*w| zH_iF@^EKtTWN=J1YHMspgRh&@C zzNQrMj@W^{lZi5{Dt37?dol`#*-S3G3eZ(-LEq8;dRa!y0RT8KIIH%7p7OQ)v>qk( zGVT;h3kJrv`Kkw8&RAeKO3D21S(kt^Xx{F>i2gWZDT~y>< zu{9&AkfTGcrS3ySu$^&lHVz<^V-_<*pseX|yK2^lA>%qt3Z%rz@gxsv*&%4043bL-u+xwA!v*tO1li^hJzQjga=S2jBr)2#8DgL1L( zCKe0hC%Zr!Z(70sOHbf$k?0X@*(DI{G)~V0k>w*JE4HO!u?L7(qTP3J^Atb90hSej z1VG^sKhZ5Xc_ak11BlQjdXoeTwq|!6;R<=ZgPEWX$F$!LzGaeeEDb`#`r*kC`6^}d zRu(gajRx3|`~}2yCC7izdcWo2mMJ4YTJ%AWE;=26LUHt1z8yNs2Lyn$R<_mnX+mz} z_s%IUt=l=D2ix+sQ0!9Esl}EYgsJHR(_PstqAF7GA&EM-<}OY;7U7%aj@LIMHBrnW zUPR_FA{Z#8wO7eIN-bP;T&*U}#VPWZ`a7IwuEdvx!us2e9d zb(l4(U?tyU(B4zSo8g-?-DmfTT6jKf=2gAK;x^JLlsxEjD%su-+Lzf^VZJ8f5n5jR zN3OzS#IKJ4;BX!|7Hp_VtVLx=!I~Heg{;S+AkAiFk*KmB|1shdp&8td1JP0z0TE~z zwnh-fF{x)ZUe$9_d(=COID)y5SgtVJb&I}fYRZ(RG?$NCZ{}wi%FW?Z$Ow#-3jm__ zpH8j*%qK5pYU>f?Imguqf!=E~A} zh|~-JVT!$9G-GdU0bDK?&j%XuVZG{kWkXV_uYrS+R9g8cOfeze&q_?34y>A98{x(6 z^Bf`z@1n}3!Y-{&7C0>aJ9_&gaOEJ06Rw%aV0)X0Nl1p-Pm~%J<){+ekuhaNA$2%A zi(&=0xrK%v+JWcF5}ZOIPnbSv`+4A#>9?zg6hyflsCNjq*1e<=&U*MQMf%c&Y?X;R zmoE-$ZY2lK!*-zU4!~%C)%Z>-rUE;n-wk0=3R%QrU6rq>brf~vcU+Oc+{2rDjdDMR zn0{+(X$!%4XdC|&1AshnaoCW9c&)G?S*WL|F%?V@0+ob>$*n0zQiq@EuG48Pa`{lw ztN3NT`4$B(Y3B+fHeKyUHU}qug@auO;3P%RF53d?1Vw6?xL@1k;bVK&a3zb>De*a_ zEXfVMM~sfz(T?%_vuegy-D$5<6+X46P?4y=EnYrd>gJ|E@%c~iJs$54B=C3}iWqJq z@c6tavWwI%nRWhpKPEKzf<6;+a zsbNss>*@zQHPn^>0KOf*etAh3Nup*$QR1jz93?d8`V+HjR4CGvA7OCr>L$-SVt;O5 zvt474ov8Jr^l9bZh!0`TU(Dr7dKK_9&?0Qcp}95{Sd>l#^>2OC)h=Jaa5 z<+vAkp*U_|6B}BOmr#mRq#E{^S6)xk4;S^7O)JF^cQK91z1!B#C0W(_e<_Fmk1u_L z*cb+Or?+SqZ8nHVB$0gmM7o~H%qBY(7noQN<5r%XKC)l0Ne&;TfJG_FUQGIuoOT__ zPgQ=3FWZd*X6T?0NlEetoQg5nsQj~ck*3qys*ptgTiu{_U1I*LAt?Y5(jRF(1B}AH z$fGM@x|GR(qRkCN4e3bMjHx2ajpvAY{SGH-Nhvl)o_KqZF%<7LBsvJ0<|JsCaub|9$v-JUOzrPd~Q*ewCegdRp)sX_pCSh>nDw_;Nj~zd8GxGvs50M^?TUyjt^a^iJNzhoMC>#| zVXzmVg~NU^+(zTXnj8BSfS0++)ad5*{=MK)Ad8d|eQy^03*Uw93s-^*SG#O*EnfR; z696Bslz$39G-REGl6}W1%+M7&nj`05_DScVNa7pS&jotqJdx;|a6tUp{ z1&Y&r9{?;uQlF#+tmFTvT&#(H_uw@eOhsEqG{&p!^4z8in5AjSI8=W>J_(G{hXi+c%lBq5f<>bC4atWXo^2X$u9LL@AM6Kaj^3HL?mLd zI}n0nIo_X#pxytRhlT%6%7(%2->(sM{#UJ-N56hNz6Ewy5BIKap2I`xA z-`uF7Tscq;FFxIkP%_CwQafwm=oxZ5X@{fL7Y(6_)%=LyNUMMWvl2SGfmxT=RQ*%4 z1urOsS?X@GAFfLiLn7H)slMTB$LmhpFvi}JP4~)g|$O;^Kr5wCNiK$onmog z$7yEh>IiOuYwIGOYyenpXqbvk5FVMFU@ca$lI&Yu(t)eHwU^9Lbs=1kxh#+D;1N655FouN85EZ>kY@E_;$YP* zbX|=9lo-(KZzF3eqw+G>cxzY$8C0732jMTW$Em0ll;65H3%#; zYZkZxa?+AlT70mtJ!NeX_Mazhqiy<-FAVPQX3oLP%}lY@KMpQ{Bz9UMqTOaOJ4r5R zotg2KcYV>qEF*4E`<{6neXrX62;AD{H zf`Dh7*Qo+PM8MLH@op&N5ga=E9rl64*CPyY&-0_oO7%fymXkE_iIn0@FEw%amBMMg z&_YqAx$MRLGPLD995A4Y;)2QxX^PLW+y_|&>eNB0p{ATRep8D%a!wjSv>op3*dvU* z*gT#?%0@5tGCgmF_4B#}k>rvulZ2wpb?g43_5TPQJUM_G*Z|er-jL`QkscB?g;$le z4>Z?23xHnXv0P-uA%cDpqvgQ_Kx{uN%q=DeWYoh&E1S=Z62ZZUAT8oARz$frOM>kf zRF;~rIb9~PP_lf)r%;^-0C6(kZ2&Nl#!r&@gA)puGCZ8Hh&w*YU>6nfA-7zWNDOzp zxT_4?XIR=#;xeek`yqkIB_Ayxzw`a-;k~#8YNKpmLL8}s4HC6T?SYY03=}9imS%FV z*jFGT@>dy8Q)rmtZsldyf;c*wZBmG;5p%H&m=+=Zgp~lura$fnUTUn*;-`MTM43cF zVy~?Dwxzn4i=FSjR-TYzd0V_jSsh$!?)_ooVC+Dr=Z6$SurHkaf0@iY`o%0Kuse-STD5;?`OAw><$CqYWxWQ+YF7m(;pUd8CJ{TJ7Y%oSkeK(xq_x*ZVM7yb# z1AU;5lS%pVwruwPJmVYHh`@3~*}A2b4J2TWZK$OYAVO)ur+Cd&AHHBZBK4eXFH(v- zxk67`N?W6Bs!Su9V60p(Pg%WLv(iV8NDBHA({uGS!!*O^720o;M=OP61cMNppuu(+ zk=KijPkuC3(Xwxwza-?0Kn0dE8X;>UuhX0z5Dk)Gc1a&HrV zhbO1bad*ds#ZzVol#MsU6uAwRXAI+;n!WV0j-=`g4&0JFY zpe$_70*C`2Vdnve)rBT+GRE_iH8N zrfJtD(|4BXWoY(F?`ogtL`C5LMN8umICX8%FOG5QZ*SmQzvx+DH4SA)5s!Xd!C{`W z5>w&+9vpW9k(fWha`1(CZ{7UVF)5P=>dgF&{0q%}p5ZpUdHX>&`S0c_waH&|21l65 z3Z?je+Xx2x!4F=5Y#!jLE9iICH?jNnriut@;fv^v?X>ZSB&Hxv#%Hu|B+6(7;!~i9 z_UbB983kGl9cCG2W{ZV1X2lGwLY_HMd*NV@+r#)2Kov-st<4guqRzn3lY`z{22Z%3 z&8KB2wBj7~xYOUSz)DSU4&(^ve$od2wItKd((joF`^QqHo_TofOI~ zK1mOs&4S2`r*4MSzxa_i#e9a157{aa(1@fry|F;5SR=0>pg>Pxj9)aGi}y(4<}*6p z)H#$Zx-PNWxxEh{_q-9;h8RTX*LdrGssAJ~U&9(g@IfFgIQ)c)GKq5BdhXaN-z`c0 z%9i{{%)jn0Oa}al|8qV1IA?I5z9Wig9!y8J1iP8ZrT<`|hkm;QQw_ z&j5gIa9~_+P`fC`#wkAQAKeI-q!wo5zK}pSNy%RboqDdU1=><)%n6Qeg6|_~T-bAk zKo0<4c32MJQx@|ptlZR6o)a>AosH&Cq7niL7d_|waZ3BItnbp4D#h*e% zc@i(-60pt3%d9BZAf`VZoojgASs5oax;a|aD7Qm)xdPSl?Y&xu{U}}sddXHW%yG1Zv=g>w9By(q^xhH36e z85q(y%Gr0cVM)r*C@Xpl;C(2wyq!vtT+*!M(M~J=mss-%oN@(N6Yo*!+MyF|33T3q zH8Hu2p}Bc+^=mNMu5de!1S=S9OyN5dKq0v6l}kVjVle zFpc+uif#AcaL}sbec-3NI?P-%wuuH|$v;P|+uZ@6SR%zuJ0KBNE4OZ5;m(Y!qIw#> ztB^?i(%e-j<#QHomzN{dn19?&1QnsKEI+4K2ivXnsh#q|$;t-zlu+C^#P!oU2Dv2>xS3n*) z`faX(v8_{R&M?&=Age3iRXkdvQiH=46lNZUvkUsV0CJrh0L~(sab<~Wn$}7Q^P4BB zh!Q%%5A`uNtNWZY8qM9tm+9mqw#oM<5nW{J`L>c9zp4R<+7M4L z;R+VpEn>@Hf<{B!7iJ38Wt&{Vprnfx578vx(aO@90%Hj6r-$bqb9k9l;uYvp)LAcr zh$ zTKhTkQ~99l&p)auJ(3XV-(H!yZamYe1K>Fbgh0mfM_}q~MMuQWP>;~Rv!bbUMCSX~ z`F-qI86P{k{fjLPE7Q$(^fE;1>(+M^hhWQsCc>}{-PwWXNxy^x#z5aGTR&MigB{z@ z;FMnC23_)xkK(1GpNnh*#k7NMrk}#CM}E{`;G>jThe+wd)zEaf9ppr)3;ji~=07x_=iKjGE~&UAZTA z1qSLK2P-9vsT~~@1IUA8x6Gf4%?%0na(d$r+)f|aSF_qfZS4Tp5WJXuf`U-2SV}@PYUtQb zw#2K0NWbn3Tdy|Ov0Y{A-P|M*2_(}pV^*^nY$%GJw$#B2V4sgxq8^Zob9bOk^Hf+g zrsmSccTv8#=*2qoe4$Z2&s$dJpIw1)!Ckui08UG0{c3?P znGYx=b7uw0{5;&1n=D@9N$MYu4!zF;Y$h=i#kubY`@Zcwq7?A|Q_%4AKoA;e^g&Lu zE?@V8zX&y@OhCL%akc5nLSp4vNBTLqvOqY{k^=|^B#XPd+Kk~U_tdv~%-_fuIy(}b zq!vi%#5?isOndd!p~G4%ui=|jvqh3Hpy0~@>~nc90LwZpmP9+QyLgs>i22PpN0vxI zlDyCIbf#^F`86zSP^zCp@+EG84~r0jtuhn}54>|aI)I2MotaT#tX8^s=#hHYUsu`i z_GjSPXt@;9(lzO+l=|;WuZnXsJtz9*UMg;a4%|AGxG8S#zNYXYs2fs`Hm;lFkiJ>On zNG$1gNIWML$`y*wmAUYl%ceKUgEuottf=@w8DRn-!Pzg&1MnW7-8eb~QPB|fAZ4AM z8s@}9jK7NaVA9lNUnk92@n7J)6;qxJzKk;UK&)>nt`rES1miMf{nz^=H&l6oR@2ux z%2jrpl*nscjb4C;RL%)s?n~q#jtju7-O3~Sd;i#QTn@@=uh{tv9{{IDv9Oy59OB#I zyZ95IoQKOvlQE!2J`*yIR2VTp3p}RX+59H8pE*!$On>RRWQvP-%7ZzfbT&ZZeksMy zbYNJO_kI-FbT#N-b3+~zV00WX>n!8cw?pNKvZ7$3^3SLGxL&Ie~Jip&VMtW!(nA!%w6lGBb87HHKm#OoW2!4Nfh6 zDh{xFcz(Irlm0=TK=uRAau7yknBSOiVjR2`{BIO~EG(8+E`>T`xiUL=18h?eqHfgq z8qH6|3Rk)F;xrEQsQAwPls5fOc)B<BqS%^WK)dzIJrz;~x z6@%%9K^woqB;+c&nHucxkLb*wmvL4ID&<&?{U*fkA5p9&Ez9oH1J?jZFHd^g?J+3) zNTcwFu0otUEHfy^e@13mi_?GgF416mEeHF<*@fHnsia{dFHXzK#cA7W`2F-eljJUg z1_>{=w&>2+K9J;)^9Xjz0NDJTV4IsnC)#-t>Z>eDjiD5c;tobt8*?(Yv(DmZ0GrLY z5DL+qn>m-3G53&YVLclz|HTq3wtu)ZETH_EC095+laDvtru0*uQ`bJ%khhQuWVv6( zQyl=TQHpM400i%Fk?xL$RJMz!k}oSvRUyhxep)g(#kQ*R;+58F|F zbz(bb8trRQF59LjCvB-K5cGV%rM*U^Ii-Aay6P$UAHv__a>D{#ttS%mWujD5=1&U{ z;ls{fAVRpup31Z?PBd6AudXJVC5iX7rHa<*3Hwipj{3t|JnkismxB-?5CkC2;izZR z^&*GVTAdZqF*@i&5Jv?~6iJ~+|0a@bHPK3bPk5Z7kkGe9R*6=lZ%tfewIk?28dqYS0o`5pt)&(mmvJu z5rwW=K?||Yc&lRYWXI8!h$?(R~> zUZ!JGiu%6fhjLijzMhDU&g&}u&Bn<0ia}Z!cKf)M*05K4_R$U%2c3F!;8?m^KiiHB z4mT{jK#1~UzTqqNQDf^DvMTqJIlb2(JcyTfnD%vAzShSb6NONI))0!*?VxRKA^o#u z=vicrvRF>h+OlBur}9U_plFG+yZtJ9*dAy!ur<>q58HZhN>^qA~glw zP?C6(p9==!xj{uu{fcooAGCQ)>ow*zjjqn0i3ps>twy(I7_6J~7l)|oX_ZB=5jyHj zyXD=DdOKRXj~1T$pOaf5Xe5%{?phhVRB`JYJLPoj{~z|F&~q&p&5KIV8VF z9&TMNXr_G0DbgVZW$D?zQr=1SwSN^}1A}k_f7_i~0MO6zeWDR4(d#O^$~AKw44(Sw z@YHtbAxz(%mV!wRizofDkKs3!ucs zldq*2kt&I|EQz{XXUzL{o_$@IoT6hRUbM!yw*OTX3AP)m420c7+r|F)<~V_^N<;_| zJLx!>u+S{nCo1A`#7%HycwdXGEAWftnr^6-X9&Qvm{+)doy$@eyZKX^GuyDu!~=`D zK|lYCF81FCzrXqH5fHdV{w14W;YQhw-8NbzJGqc0XW4?%RmM-B8M>m+0eDVqEQ>|} zE9NWW_wi}W3ZYTmBHc|iwh^qWKd*x4+P!6;2@`DX8)nDy!<6j5tIWIQH0)gKjF((g z1Moyp_2&!jaMhO87}T8u^N39EqcH*zuZ%uYw34}<(B2|#Th>e6*0QlJ%17LeZgdw^ z8*sH=!@Z+(i~iiHg?F}J&>VFPg$uxH>&89#LrOwZn!-Zi&$(6 z_WGC;DpIs2`PE)~_7mM+MMZLZz1-$>F*iEG=+EQNqn1ds)xbDPf*yc@wA&SoFnz4Y z`Hj$5+N;$@d1o%q-2iR2WD8v&E%#W~elNO$*)S zx9v3-6Sh2mZH9l3>|fkJTB&v>sOJD-Ur^r`@)ENedM^rZEXz^qTm&u8xhAbVI|JPa zI^a_f0DmG?hFWT(Q%;mu+TCR<|3>jsnd;1y)v3ClTVz(CiL$H9V(5>JycD_1nER5M zmo=VAyT!C^RPlIr@PB@?0l0A4a2g?k-yM(s@b*FHJWRj8O7=Q$3zDT2XZth1i~5_^ z{4;51<-6s`Bf0Y*pP5Vb<^lynNwW8J5lK+0ya0rs)=zW4oIO{_4L_2e@9E!Le_ADx zN?P(K1}V`jqf>9`&Z+iV`(!$aJ4wlPP()4cbvYjpaCMObJW!6Il1Ufw-m@7}$Of?= z$i8Mg-;(a#p%Ykv$20BY)NVLwHNP(RuGN#Qk8R-GiZu6AE;{{i_HVNLN8psZ!ELD< zc97i8JWeJhZU(K)7fxSINdS*P`D2=Z`abr*u_me+dEVR zRIzWgNnsOA;Xl>!J&OO`n&ac~HjD%pc%D(|gTU>`t?ja!2C2%W6~C4(sG>y2wcien za06xGP_bxB05|Tha7S%lvIlRn8P>gl8UUBIGV$r**BDKS6jtf3jVfY#ZmqkGJHja3 zMy|32c(RHkVUSGm6lz>*!1+52nf5ymiIC{{(2{9FVeA}#;)%U=AsE<vxgv(pP`%X~AMt=Y4`uzcn2EOzG2m=!698r>5B56NNsGNT1hMnpg-<>R% zJj*^AGt_?i@wep#s?^vER{wxfXY8i%Vr&V)a?%`l3vBq+&OUBW=rg$$I_&l34IqnB zL8qjzqRh`|l+GO>pcxadIvu+oVqcw&-;tXYC5|gz94zM9;mKjn8z~uzCfuD-n#wfFuxhWbR=Oe#eeY1kEfw= z1yn8ZmzbZ}CfQMwGcXeA@<^d61fC4w`PT$smn13>Bao^zWjCp|kz3u4JOhjLq~Wa4`(nl!u|pj>anZ@P zDO=j|cALPK^W*e+@Wsbz+H0)gC3)1r19;`ySN!X|yz}9_?ZE}{UT6e-WF$oiEfuy_ zP-J9|VF@_=ag)_2`dMvjjfP*XA|AG4brkF?D#!;_ZunUb1|*sDKfYwtO3P0p&TP`R z`rUXZT6NlvQj#Vw^(yyAU2$~F%L>Xc$Vr245F%D&4||XgEFmZ0(t^q_lQpZ`r6tVS zs`UCwnjLq(g^#-E^DI{p8-Qa-v3L)4PN#D3R=hB= z;cC|43BvuNE*l<YuU~}J~1Mq@~#~Vd9`bN`u<)X+-8f*KW=PCn-vM4Z}t9( zw?w+m?MtXC_oU}y&X~23)J!3uEAav|i&|WJEDq`n;eN5~&vZoJ*MTE^C+>tNU7SlQ zibxgXUVOiHSvd>Oz2F5L?X0eA#^F5N+r_i8kzh42#py3GE2m-9dOj{$OO z3sg~gpw(C3CfSlg+@&`)HZ=uaqDZFO z9+0qVsA|`O1-olU4SWV`2k0dWY4Qb>W#o>j%ZNOnlCj|jSKmUZ9>OpM5Y^nabjMJa z`pG#{(?)*0Fq>LR4kOop9y`5uD6fvW;wkbtxrDo<_{&f0gxhGZEdL8ZZGc}Q&wdq#z#;GR4ssz`CLE4G! z`5D+`OTT#7YB%B3XO*?qVKJ)YwPMt(d$xg}ppFa&UGF$4v=ruFH`;{V%t=2K+_t*f z7K_OGLu&c%3Pf(M!&aCpT#tWB4cC4reJC2I_5?KnB53I)-^`SS&#`ZPBMxJHzXUg$ zT>QJf^{H3;)KwuROvh;|{r9ws75PK#HN#PjwS*Vgd9(CCECZr+HQ^E0!pZ5W^A^$u zeoHsFi|ifMZa&bf!V5IXFQAPZu_RUP#QUqeL+@WW;iVH>^|8=0;2CaU&6D7KsO|qZ zSuXfP{fq0-N?*VLNPH8{yv?3mnjq4UzDT|?8q2mFI9gtr!C`d|Lw5&XOehcThoz$? zLm3kZWjZM1mq-+Gm5Wwpb}>~je1kqm5n}M*568b)tj1rL*5qqHS9J9I3IKR~;0VRx zOL<^@eX@LGq4Rzh6$)}BvHb$5^d%ch(t&SQ8Af~wBc-BRJM0neEt9Qkqaj37M6@tI z%z=A_p>d=XQ6Pm|TIyc(EmBD+*>O9Rn9-oZp4Nrbtw>Dnhw=?nTSwhMv`1_L^7gFK z2D%q0UbnwiX#dN@iKwx+?USWgAqfTdTue1S9V}esWZFdHYsv>H`1*u}>W5!1GvXwr z#p)g=-?XR29w=MM7}p4z$^8zhPF(-9{)vu19|G5>45c_}tmSr0 zgJD1%yYX<@wjCcYCAgqi^@nq0!}+Yv%f%Ld;e~;W0$J=9f1Cx;yXu!SD3ww|+VB8&a@+kaKoFMOe`Z@rtE9T{YjWr{ zZR+h(Yd^hWJe-WMNeJY9qxwV#!<$-f_S82{o*M(_Sc3`l3u<>uHc7vTjC8_{(j>*q zqys|Aa%VlN%bU|lD$iSFZ!Fodxva_me13n7)qihLJh1A&!@S%tCLvVk697Oy zsyej+5R{KZ&wOm=H;b}V4Lm+)b+_a%NXBi$4y3oU{%YaK^XUNw$2QtL_rk z5s$r*aH3{`!8ONt5m#2zdOp{5&@ZA={*}k+BEwW=9s36)9Xqt}Q~i<;Sw_yJW?S~M z3|Ih`tK6RfW7OldLBZi1rF>6Zmsqxql@$0QlUwE#%@S>>v}icbG~Q5S{Oxe`ZYG@WW?WaYKHlnmFvY9JgX*i~=5? zBc9;w96&5p#yP5u$bnU_?YAipBMuJKmSz4^MIX{`emR}Hxmu+T zoR5D!ZJG^_!N*(Sr~kAq@aRi3n?SJ1c?>7EIfy_tQhw1ORg~FM2XI++Yb$Z@?3C34 zAlqMtwIjE0GN=$+bhs$>h#ss%GhrjHUtRc(=QpodrkGe$tMG(=`=1K!f0pHLxhX51 z380_%>^&ITU%vEWjqex7c_kTY;{pPR$~Aa#(Q zITw#oP}f58puiFRTf+kHZA@XOM?s;)R2%?@M1AQ2w!%ILPlq*VP-)b(?3w0g=<|cp zL7HXJUGzkKVeqG~9e$SGhkR_2HJo-0K@?pXbTzGwH!`3Lz>W1VMef{Fonn*%TR0uO zhWB$Floe|ncP2@DvkGlgjd7cClKh`rzjK+{?FHOUm3{cw94YEg&xrb$;U2WsN8q%z zL1_kRCOw-CeIah@PYNPKvM5uFFqEUk=lE(if@E;amK5f0^UkFkA0CYqRg%fU zVgEPp)_>}({_pvI1kP*#EIXf4>ApnOmlN(*xUqb%3V}ozX@vwpw_?k`eyK(T5WQ~m z0eF%S-b6@9jIu*-oKzf(2(g|EC(Ez0_*w38V^zs2W)|(O1X6*;Gv;TqFjMrQKTYoH z{XLDJy~8|S!lnQ~@00^TfJ45yp_~v(ov-hyBnvpuVDEk zceacz@Ev8VswV2kQ{$S~M!J}9`?hjKxC{n_i8ifFiWHENj)gW--B}kh101iaN0bofz!DLWmvD^^7w85;r<4z z#xfG`yXH4!KFGl<`&xtMiSO+a&FWu_ASQ@ddIdb-k-hCxw<<)J#RMJPPYn*hOQt^w zwJ4`<|IaRovBO=WVX_?aWFU^jvF?PFbPf7_7-GoV($p=_>J)=1x6OCJ!-x$~T zJ6E*+4|%&}m#~UB0m-7M(~1`vdhZJfu-(*?){5G2u-wE;2PQ?XhD}V{l~+6NZ$ns%~M-aA7ZO1H=Q=WkF?j=PLQHg#V?8$fK1$ zfSR}onIby7jHHA7`Q>P)RNg27f#$MliY0xq74E?pnjko6SY#GJK;W57C^prSg~PWJ zvz4}SP^{3%w+eC2e5N~knM@pZW)7K?8G;lu)P_-3cDgPIPhbRvzGI<(Zkshn&R%;l zoLa093hfK1pjrk!-Rr@2KwB^@K%8%9r=Bl@&clcSh3SjD;!^vr;Fn)96iIz|ab&As z;DRcq&q&L?kfQkzaD9OIgK7ZbN(d(qm1kIrlOk7+AaXEXCMkmQ^0E%LRtW>@BBmc226> zzLUrZ*3#q(POx?D*DDntAWr-@dHW-9DvsdsMtL@Chf1=;O}+aR)P_WMb2Y7?vCEmn ztgv~X#sdO}%w7R9>MUw)RdG4lXSBatYS6ioUg?5sV?q-5n~Ky4PIo{0dY@_?4oLTS zS{eK{h)13X^U_fu^ zC+E-6U0kfo3hmY36w`4}j+_BN>R{1yA9@3kP;J+rtu#@>Q&KMboSLaVRUSu4RLpU?MCO}U zPMwSfZ435d&rYUB@w0{T0YpKEb^uO43Da2t5(>@8qKWtrvm2NGtdxvf-t1xO$_lCw zgbyhIeD0aVDIVJ6lvE%o6?3jGZ!9&6Qy6n51ZZqgo9L(A8m+vgv4B!I;1$+!U6}-1Y((^%FtWlrN=S_pM|A1I|gF&(+nQ^F{rsiyr7}~rs#Y0 zag4NJi9SR&yKmBt#!U5zq=E=eNqk`L>Kqoxo#N~H*nj{9&y?>0U;+7;NZmCWa-O`zFqQJ0Y&nz zsSVa4x@Qk=ILiOIm<%@2)xD6QZw0*>pz!VRvU7YE3g!txafXw5*1^hks`zJq^`H8B zFzl*7NCggKtQV;$qGFQ0IhM>a`(FICtkl3C)_ndICpN_&cGrk3%VJ$su>SAH9^mKv z<@I<}5lR6dL0{MaCSn4ST^l0b1K0CRvdt@?Hd|jnS*~CV7O>Qppo>0ngra`juJ1u2 zDf5`)Y~eN63MZ0njYw#8jAyDlv{RsojfsYpmFDM|TVt4pYK!V+kKODWi2f{q2qnA+ zWgNq``kt48-vaUUVih1HdNP#Iq5nOL*v6$?hyK=eSI#;@`m$DJ%5pQjTLtIIl2>U) zRq8J6Zn%z}skCxF8Y2NI@JkM(_aEyNhvr_8Qj2s5E`sT*7fC;f8!yhG-}n$3Y8X~7 zLd2eaRieK4r7@IQ@<{@@-geeJV|}`=oGpAsuiY9kjHrS~2SycMBl(B(w#{kt_&kn1 z8+=N)*@!Tfr5WK_labQ4vg+(LN2C{qlh4P^5 z;x-!n3kvfA8)ZxnTo)306$IKC{tDKuaya8+c;sj=7g8NlSU13vC1r%kf^a1nzyU$N zZnyyuw+hnn@9TH5k&rY54v-x-g2jUw&ljWNspyZN^oNhY!m|x4eDL+4{Oj0&r0rz@ z86Ir>2&-Kj6lsWuRaPK57rB1GF%ck6{r%M8lfuvip*bhPK>Onx>tE_3lX*;<2VSmrQ~`M3Jecx zNfIA^I8>B8e#~KI1(5WN;e-;dW85nw9K|6f!HmCC$%>lWwz}xM1ZHT!gT^bGi|B5o zF7T;cT#ov|eC0LFW%Fk#Q@c_WI%ZKS=`VQ;W_rK43*05V9{@iFt4A?mSV3L(f=eA) zCDFn1AC(^d(yAZ-_-NU4-~v?;3cuktl~BJtGAR1g$BH~&>RQC2n6r`0T6YfW>|*ze zmh)c#nBnk$%)<17;PWEX+tb7RSY&4R^L9+qNXJv9Pwy8p630&lf8va;$bTbxSLDw9 zbBy-+M&-%sEI7*m%-+~K-J779HTi`~;BzVjIz6u3V~@_I%@n-=}*x z2G_H0>}vawPt%Z=S+on?OfBYBM%_KD%6?1#-uBGrM3b&?XbM1@z=~1T#o6c8k)tif z$1+!ZyV-MC^>wIB%Dv2@gyv?-yH?)7$@qG68Ha!fjBnp`e*Wtu^AWf%S8%jE$Yfv> z__BoGQqe(VkRO$3(xHeJ&E{#+zS|iANRt%cYz7}MNcBMpPJ@#i?sST}S##T`VUKb{ zKpVlmBthR4A#4eyzFDPP=i_cw)~h+qQHmC?*c&ii!ngA;1@MrId+p@EMrA}uxCh}W z`weWBTMg^zM=2^1;e;*ZT(){ZzyCDyQ(R!mNZ##-Ni%J?-UMKUa7%X(E#947AGaKv zCMcWb(uA2(W)P;-O2kb&(jsQBupWF(N(=6bf9v0)D0h}uY=tgsW4slfJWoYM@op>t z{tBn(*+MTsx^v~4X-y-Vd_L^NtXWV~ax(M5#q4$j`Wmg!BLwJf5rZObO~0B03?`P0#wUVyfH@cWfBc@l3#2vS7NbS z70YFHI|pgq0EAbyavJbOwNe*S{hS!?l1x?5%NfGE?lJuAmDti#!mivQsdjA_!*@c(fc|kEw+baskpZ)@}QbEOhgo2dlUI zk1W!^m-w94oVV5!lQIq)nf2_TASX^JSHo6=4;4~0|yE{RGI|O%k z3l70u0t9z=cTaE+9!P-TA;CRCgL5}?pP4!5%x~s?-+3;7z^0*_rgp7bwW{9ttuKyu zdfv30eHoDsviy?dK3rxFWplhZ+JLwm_-8PS-yeMP0v4`TdzCox%s$2pq9D)(w;==vzTHiT@HL%Re^eJ7j{>HWP*V{ z!#CXps@qNuxzzlf@Bg76^!HeL4-U>q zL?zKuLnGSdD#}7Jc~30$#@+A@n|%I<*f$lS)cODtn&%<_kwcB_#2U&FuQ}V1`O%0% zy&Em^<#diw`zRgivpaG58k3fc3rN>c0w(R>%X}3K|Em zlZ&qml&^_`WZ<^HNl;Vn$m#b-5WkUP;3H$|+vu(LwP(Qt7&d6BmJ_6-!S^*i>`d)*i!-K@ zw3jE^$F68vans`X)x0G>7i(VksopRm*HTks1gLdAF4wSoE`PPupN#T<^6}(x8DN$Q zseQhnAq0TUG%%MXgGg=afU*&fy|-X94eAKyvdmt+0F1eOGAMLgATOVXQnJx4$mcFU z6sRFJsKWGKV&z(lPs%Ajlon%XQgrR{)Q5wC4}h_$19MVD8>J#RYq^-SM7@yb9qwnF zhJWfSMn)NJUb3<;(6Eq-A+2vrit_HRjdav7gMSK>N=^H61?_L|Ui&RsjC4Mp7vJxw z=6lA8FCR1dn47*XX%Mcb`8|GrsPc^|qgG0IV0sP)Eet(oj|bYnJuR?#q5LD#b%JqY zbL`}Sl5BI5fET!^9!lyHvR@|#NAJwAT^q$WOkE3lwrz(A-%u^{i~Qii0XeO=K;C~0*V@q8;0pbVhK z40!Aq2pwN!850W4s69Mynqy#se_`7*w`RNl9T7qIy}(BaT{_nm{_Z-D zTfLKacb~t<1DIo&6BCd2BH{>+B<&kjq+c$RJAUaAE&61wxDw1a+T8M1M{bIt>&_~u zRxf16XEy0gJ#V{6pp>vtkpPpME%sDRW`;1BvNGC9WCr4sP8zkBj-hgdvV@jjXQ>BA znP1pwsxT5_*mVq0VsT@zTXoUuu>*{0Xw7P3PaldZ+|0@S#RU z0@l{Y3E{R?6?y|aRtg#nVb-eq1<{8~wKgkPCLdAIrd|+z(Tv;w_m!rDJrGz4SJ2fGD55M++ul-#*#e_K zkR*xrd9jZ9!{t)Ih*toWu2>|$P?wgYVT$EN#!vO_PgQec8hT%w^pEYDDjE`i1o6k= z^-!P-hV>3WVHxpNbth8gbMWGxE}_P@jLeB4*rT>m(N>Po8TOydA*hUbd#zoXxc$Id z>YhvDHGaAaP)EfoJp=+%u_-S#eisacQCuLh>v*WGIj`A`%OC%scSL;ivE@O=Vx|+x zP;Ve&Bnf{LHHz)#YsJS8s_FGWs%UpFfR$lVRaq?zC(l_Iorl{ZG0#?`P_w1VFf7s8 z2M&zl-tuhJq7uY<>HCJ3=BL2k;!^9stpGfo@o5kMWUK+Yr2|yx7)N0T$eKf!iU_f( zrZO#WMLldj|C=xBFKqd%}6pA)lL6o)Yw1MDiZZku9ZZGzY5?v)H_7lhB=BcuR zo=bwzWNY&qRhy=p^+15p5}q|5fC-MldY6zM6+DQ>Y|1F6D>O+=Vkt zUK>!jAKCR_Ww60sVq14*zIW21$>kJkBQb|kgc`av9eb&V+g}kZM33x`P5Z1#?g3@m zxiQV0bV@-f^Cf#jAb^Qx>xjUi@QoAupo9@O8P2j%?#6qq;INWzh2)KjX9BNiyz;66 z!NpG68`f^0F`MGF`Rm^sXpQ$PQsUq2??6F$?1Wi# zj0~;=^amd^W%?Fo46@7_I%^w^o6kt;8{1y~RxQQuz5Oh&*|N^biZp*Cs31EDzY|{- z3Y{HN6!-CQ>eC-JbB4>x`OR-4x-BY+t;W+l9GL<0!g%ICs)jxZ6#EQ-=V4@F4+mk= z-(H9h_rp^UDESuwohgCz3Z!)(66?Ve43;s9L0X#&5nL|-t6q&!bm#zoNQdDXeNA?p zOk*DYIL?inza_7&w7F3&orK0+w&)+&94A0HnQYQ}d~$G`Zv9j_2DgqxCr0sFCF`M@;63`_Uq3A+iyb%bg67ApAE} zTbt26U#Ww*6p4&9-*tq~J8vXN`6D%_8Fme&>$A-tlSx~rPG2}VJbh#P`7&4nrtN5U z$$4lek%-_H&MgBT!MOv3KEw~hy>y$%g9)`cOG}l`^)KFOULL%Jm*L{s=yw`6EAXHG{eOA&6in@9!C=b4ZREwk z=qW@~wMI1@ggA2KT3Y<`#}-j-a|#L*fPmTXRx;qU7Xj_%OLQ2dpEu>7{2(&9Vt-g- zRPiSP0q+^t?!QuSn4n1&?}xnuEy^PzM#^{2!Q8n70rBy@owBr3uL#ja?$ zd&+ph5Zmf1+ooMYWFTExSupkDc6a{qA3tH0qE5 zfCN_HPDUVP@H2gW`Y&63TbuE0nBDp0p2+z=0@bE|>V0Iti%7_YI_19F>@Nmh4=+ix zSUz_Fy{#_2F*b;(q1 zQMh6%WF^U#HM8?Uvg*$#qDvQIp#zLwSeS@K!)pMoPA9XLrF6Dq!*-?E7^D?%9Yhrd zh~RTrlKWzXU3@Lx%a4A@*_hRfmabt}pgF%jI$mQgA_F@r`>2ok5Pi-RnL}mDuf#~G z$t76iUTa?H?2&M*Vh&ficS5M>FQ?pJ&N8ACnRlp>mXWh^TOh>f3O87kT*HI9M+N;D zkM+PR5wZ*nD4-cG_$>uCq_}O}J0FM4+$HJe_{qMOl=b~} z9t_3&1lQvP_~wO>#J`UJ)U_<ZZ0GdV4$1+tp~t z?S<%A6&7xtOUV=W(n)LG244vR0L8*P;gi6CUO~iYm$3UHRgM6myMttP=_5{_CSkv* zkt>S>Wj_m_Bdr@;Pgif}6>>-G54Fx8Jlt1V+f2?6W&&7DCSgB1u{!}k59dZ8fa@)u z_coBqA_$4wC?0>mO6=Z7MWs|m&%8X-{m_2xH>IOMh;7}w$E-W+VA}UF+v|r>-_8G| zdD1g{AErsnnMo^SUGAEU=Q4PQnkR^Y0u3fhAn3UWBuIw`;-*gIEnnj9Q$*1G*@C;{XP6V2l}T-MZu)^oP+_j&B!@9Y2l*QY)O3=SB3e0f%Ec1Va6NSlIsM1ma4$Y3zbfLvHJE3V z%1}EOM|-W_K?`HzS|4$i$8E3IlgY9x`#~`HG7i-mkaFerd@w8x(k}HvI=QheZWwZa zIcv;0loxWFJWQ{;5;QjkDW|S*SzezCD*ZMKsN%g-NJSh=;wPFcfxcUkQ`C{TbQFid zCm&Ng+z(p_|LaiyWb6iTS;2&G>)RY+-zaS@#|T9TBWuq&mp-pA;3PWcy2QN)DA;0! zA6f!)6zxsvt?=%i>r9TU6|wMt(##PM)a1I(3Uf9aUwgjdxEDowdrO@C2kOM`?%JiD zqqIq@oBaa@z)H(GJfsXo%?r0`dAt!0M1sRx?D>{YfTZ~~g<)Z3ah%cRvWelDrn^t6 zo#>wQXMM!Ng5gxypU2@caa|?Uh8yqR=hbxG+u-qD6b7&yuZN?s9p3fz0nwzgy#YT2 z05}v%hP``Zo#|FJS~q5aK5IMR!y$$ zuPwKYA$yKeZsoV6j*WmAUp-2_q)P&@v8BkCT?7R;PIhj_?yeImZ?Nh;y;A!kC(7D) z)M072VhmKDNa%8v%imrMx~GDjvY;`?P$Yv0Q~mk2xtz*`oA`|9;LqpL|B;|SZ4SRd zY&7JOMQ<;Hctm7q+>ct^1F?9>suXIIzf15mFQFKmC=}E6cnF9gyn*$YSn;~sJGbEO)F zw#})qpkiChM;0npBXkKs7Q~IZ+iB>;D##t3eDKXdw8(W** z3{Z|f?l1(qLbsjN@%|%r;K@t9zcrI-qbrA-}>GS;|fQ!JBYZ671<`o0`^{_D9 zgbQ90YsDrBHH{X*=p!YC!A!M`W-q&&4iV2>7U~B+J}FutFzYo|Qt>A;o6U$0(R(=|x>;vqNEmhv6H zsF5IpKxkVY!K8fSD@oWYIqGyQ%Ey5hu7(SPm4{Yva1;Vdm-ejo2S3H&;F>*rL&VSq z3ncm$vl;5Gvr2!{A#SD;B#i*#@OJ)xKq@J-V(2h*mbnoBiaBiiOiWwt1pzGix;|^d zQb|DlV#bmArqjTYW>UqQd~%8M0)0@E8~}dhEis2DeAg>%+wW3@k6+(p?4RA~l`w`; zdYyw&jytdYX6H1RL=qX}WfyRF)-kHezGAo3%T+O0L;Jxi43c6fk89Hn z)Y)KS4vb23gWd~c1Y$}uU#|TCc%_)iWKa0V4u~crV1^_trBJ6VIN(U&hb+Rnq-f|= zLIx7~k|{XQHic+tx)KYjU>kd305W>4?&Uy8xcEk;yC?SI=FMkzgr%`ht+b)nf*e6} zTikZ9i*N`Eb>5I@sW44PYiMasP6stNtHRo>Y=3S4SBB2tE%a}`K2!sQR^EZZ?0X(f4L(_Oss*g+Qeuu+=sF?K%EHYTJqwK%<}2Uz zH$ngXC5%pY%P?uvN1qQWt%okv8VFAGYrWYAV5n;Iu}lsZxZ)LW*cN00U&)wP?4L}8 zD1R#OAtz8OA%T}*u=>4TF{H|vuwa77SHHpb8-N31?+5TnQ8V{Q3E;qvkR&M$ceVxo z1$W*V52|Dh++d&TbehmF$So%sD5MFAy!A(IoRKcEuAwZUZd7S;MAfXwDyvr~c=KwG zb~`TF%8&BRAO?NQr^@lkjx7^pbym%5X|0LDOq{|`_` zF!+S6u>?_5AyDII=&1givX|O3+CQU;MvcQ#%bjAF5YUW{z-~4y)9pThz7R>Z4(a=L zM3Y=V_It?a4_B?lLYfF0TR%(j^FvtQ;g8SUiYtf{qMu!zIunKrK7)jf82$P%4ea_~ z(tDJ_iN+UKY|~E;yo1ejEO;61s_=#WRh(Q7ui&3aRDg9tu&G+2kvoJIkWzUR%=@3S zT%S$>Hn<=!4p(5|0L{xgxLm-9{qRI~Wgc8YZ!4sp*Pfe$A~#?!qocbT2!fOgobooX zPQ@jrm>Q9o23d33xM>?=>S33z!`AW4-oYBM%3QDwCovIlkgNpTOSc-YmC4(A_A-3<5LN6kJ2b@@DcVm=Ay%ZIJ=XL^>ZO{P>I zaIa%wj0h8aHoX9kp+v@#G|WkkrYzJe#SgooT@hA37XGYO_hyjuz1Ma?UPAhdf`RO` z?84WTZ!gVemt&mm6YkKk38;0w-HzBIbOoCo+}wj3F71oVNQ!VBZjFIT=0C4&%U!CG zF!QvO*%@S&_eoA1Ps(R&g(5c{RU5t^*whp7R)3}5JV%)BufVo-ycnyj`l@W|ji&g0 z(j1Mx=Jp+~KQ*OkDuRVs&+5ZsARHm=W|Yqa0h-e`5O%6axKm3&dO4V>d|a(Y53WCy`&JqAAc44zt_b9?=J{5 z2!wm!2Ouyn=vQqlMYSa@Z@ZYl*-~)7TuY%fCiKJ(zUO%7fJpwlLC*rf!V+pIQB+er z^XAtVWK`Leo0xv@T**E^2UgQvb!MdDM~{b=@0*l=%+4qb4x?7becMjMnY;<8{K^oi z2pwniEJ4}jdKs+HnF080kr^cjd!r=JaFLbs0Ub1;)*F|PPQUHZd|VDWdcot_ts=n^XrQIsxZ=VM`PiiMjD=sKFTu_Hpv6Ido2usi;??UjNp>gUt&W86nXeNqKZc+wNVBkm*U%xx4*gdaywLig{mB3t54fmAjNJXG)qiL z;8FsD~`9JZ%sk9*A8VQf~ zr5!_5aMvEF9kH8kIb z%MidoiArq!B@Cd;B`qh#$#4FCJ8q0VPE?9Y`T3Lx$L_y7bX+aL&`AH`MGhmxwM;Zmr$<-0qyQL`7j*KQsvZa zQnhP8KK*#NHvQMhDK zqFy-V(5Sl~fC`gBjJfC$4K2RAoUpdAkx&>VX-8~3y2OIXi*VS&fMy$sE3Z;<0BP?aRu`*1aH#gPQ{>?8#E5@qonyK7qHl!0T^1j>U&d2$TKrl{v zn|lf+N%Zp$ z#`eO_^)AxouyE&){ZaM*wc#jBz%BnC1jGE4fC>x=#IWs3BO;aAmqpk9IKw@%J}D>x zFvXOKyL$np&#)1h#gplm8*OtBTI?BfDx?RrymLo`Mr1FrbU5si*4r9J_PB>+M~k1W zTTn$35#5Q|#_A~p;S?^i4**Pq+mFp!SJLKZ2%hS41n)-oRR2(-xlFyFC@K)IG*J1z z-u0m3Zhzd3c*L)uJUu_E6d@D{hY7>=I0RiXV^_5)^?uV)rA0~~V?WbBU$JnZ02QM_ zPRUGmbyu;22LEA)Z*5yVs-GVIWGL>51)=uK9#~4Q=KW^U=}2X>U_=k&j1WeQu$ndj z{h}`SW>74XMGLLYEqZE2`SEx=lhPYIjIV%FQTCUx&A)|M{KE&I(gYhX(BpDwm%bcg zY4cEl)c-JMM5H{sviut3uSrMc=Xmx2%txgI0A>k`avRQ6V&)A->C}u=y6#J_<(uMg z7s7fImoQf=vI3@MwviCF-LJfleKE=a4)t0(03%_7NuVJqgiPkn?7N$VI%fFxtnFAo zc49-1F51Ygifvwu8nvv5nXnq%26m zcKKKqk@E)K_s*Va)=7u=Y`rk9lCnI!$%$kH!+QqhY#$8^jTLu$a zGXx|L8|em<{2q+M-Sfy|pwCeoKqh;RkyPG|vB0{3tQ#)0Z#>k|n~yH{ex~oe0z1F{ z(HSRw6dY%HVwYZ-bAE~&830EK4&El|Yiw$Lvp}4K?unPs({ZH9LH&tPWPihj!NhxT zvjvqf|17Rxw;es{^IVqZ-j=*NAfevTFM%DH?qPkR78RPr!z*gm!`{@=jVXL+Ggu6I4DK z60LWE-8jq<|2FQgh{aDvSiA&5%@t$|YDkPS91_F~LKZd%R31js#foIT7>6VwB+&qb zxo#SO5u=s0O%wPw!X&da_FBN8D)Z!dP*bScg<+cbzBD8-&6c98^rBt}0XJjTcV`p; z@{A4vSg65!uBxrZqiyREB|X6cU8J2j!*5G-{kP-dKSs6aqAm+Oib)BdnD(b)CjJSp zAuF&2H?(xSl|d^k4p?^2IU^(^pzK|5G`(&gdrzt|2DLcJ8mlaTlS-j$s)|#FWbKIb zY)0xN?Fdc;TI8mV0~u-&IdN|dd5cSU_%THp{%X%rp%x-XXf*iyf1OS|;Th6H!TQxR zCf&V55nEBX4tpUp4+Y~MyRrt#pMm&C=O-o4K|L*R>%3mTAWSVNi0L!!OrlQqX(cay zChr^#W9vfib2^g|@g)_j@kL}-YrjH=%Q&ZSe3sjeerAE$u7VVjq$>a*YQ9hkgfwH9 zi*dhtVEnVMExd^Rz{sc(Q$Nq#wX_{v%G3_$A%<~$gXb#E7R=Zw%_R!yU2}E>)NY;7 zzQqEtz(u0b5|B@@8Av12#8fJXt0{PT>2p-;UaHIRPErf{hJ%6-4dH!~5GrvRXW5Dp1|N zwe{Bl5J*~TBIn9tIau)5Jf7? zr&PEYJlqT>h9wHyAv&9qB6((Rja%YDB~5k}trszj)1ENnN>Xf+f8~S!2uuI=;>k|Lt_!nXl$xDai@*DR4maPp5}AfCNPmY3l)i{?J;1?-T@O{zs$i$St}N zRA?b1J-LI%&oFi~?g@G-w9OgtP?(!S3O+H)JP(Av2kAE^`0R>e&Hha7`UF}#4VA&N z!+gVeaT7z=!uKn`7JQr~DODJ+I~3|I9@}0)0W`JAsq1c}2Ff=D&hogp@vncHkulO{ zFV4=7N)Dz$xfG)Tq0y|I8VA(dzAqnz!Zp7mKCeVcC@1mR0X^22%kGSO|HX8 zpwk&01K1Vv;AV#g+y%S8gp1u!4fTrECQ=T^ag{rowUS|DSDEN@G08g~G`D-XkfMA1 z!2b($AaXg!pXp}k&Ao17Tr-K{3KQ{Y&zAAwPBq3$I)8*~y`>aXR+*KUNv&@y_DKZD zgVpQ2*j_J41E7$jAWRsp5mF_Zzg#y}rsAq(yeLw>PMPQZAWrGE#1&M?w7>kM_^&Yv zPYELlADC&sgo4X~kB`ZWm{};89@(wIM1jiwCl}G7O)8l=zy`yA)C&McavTeRbVxJJ znH)=S9?!+-HPt2jwCQ-Tl^Qf;Kb{35k-x*c1L;08-b_{|fy`E&*Dqmmiu4_eMOk%6 z`i6+bncgB0SUQQfE@RijV&i@n0aS}PG&E{ox3_$}?d55E*QsXjLF_Twn#|9$!;eX3 zMNslRnY=$-l&3r2?E})LEZXPScV`jjeedtTM9cut=Vbm!PQ&AY@z^<+WH3#kmDRuF zL^`nrvzb;A(@&>QW^;y2mOpmF2E!|Nq7#@O@^J~Y$4d1CkPY0CFUXVME zJl~rv3Fy%$&;Akc>>sVuf2@|jym&I49wQj&aloOc?-)m95q<21EDR7gOKi$Y%nF_* zSGR}{P>ZJ7g$L&ywP2npu;0CjY<6pX~yHlt41VC5e@@BQc+lRs1GYb&F_VsR1 zQ*iY);6K0H*8bV3<8U3}f_Bh*aIpuFc3F)^9d#GEDHJ~VS)Ly~i&d!-T3qFUJb+I} z#OeY4)D4X<6faH8LWR6CqRR`lE5U3i{n}9XkgC0^SE_+O8E_WH#tFyorn}0ZdUzYR zj&!w|8T7}pt8(%_5=kdwtFSdn zc38?*|DjH@LP#A1+idzj210U>bxn;p;a^*r3Mic%ML@K&gE)`yN>$iR|Np&tLq?;?+!QW;4QtVnQ z>Af^U#?;m$eqk0TO_(6?ng%AiyB>J;PKQs7IEp)aDXHFvp405jmpq;sj-T?!BA&+- zunWg;kg_gh+0soN*z4R^j+ca_O0dlTTR{3tKl|r{Pw^_q6pUBRbf7vf{S_BDkkNRO z8U8%aN;+Tm#}}N#^Yi3;026}M;%5xJ35U>#;~=2kbqFTf_I%>TnmC6T5O>^@BHyGqGPx=8xRQ@STMZj4XC-YALr;y6JXTFi{ z%XR}Pqz{G@Z^9IcXas8+ymrCSc{&G9F3I~6He4=2T&58b98O{H;-{ zFP1J8J{RF?4!&5s9@d5g!qqDM-o|q4z#(U{N|Zfh$cVuhF(_v|?%}_t+7c~kRxyr9 z@7rjWks@c9Tfx8exTw0EEDpZ0%o zJ3@m5qg`IHK^XCiB>h4kUE|;=-i1<~=W$NX{$g7hQ`dLCO_PIW{E0_~4KZFg!6dUl zr;Vn=R(kxHj39C?-wV(%DXsMzBA6S?t#fj2rK{N{d!c&UlnncJtc3EPDJW zcQ#ngO}~c))W!WbQfEq1eO{CvHp0Y79J*S&s_ z7&83b`N}W|&n1@a=WyZ;e+r2aEGm0>9%G2RK~PGrQqOnk?>`h<5fFr7U7BdoVSez< z?qrW8(cLT=bhy6{W}gj2dN{o7g{3FjKuhIXh&j}yKgb3CT-<0{ueevfb?KwAbI-n?aAbN^PKS&0Ie_j{t7V|X za1^IwSH8;g-xWFSz7ASnUZ98Ka9S5_OP{7AILjbc@W6R2cDyKagnv|fsrM-VEn-a~ zVLaW77n>#G^CwxJ!kVCj#7#S;hsrH!Sk+##$lBHJT!4v!u|EL4anXS@>=ZHCz_D?{ zv1@Y9vJePA-d2mSH{Q=U(tlityCc=x_FlUW7<9}xX`*fFE7!<2d@E%i`@#6luydvR z|LDQ~<2F5c_MZxHLm}o_QQ2U)5w%416C9>TZ0>U`MV8Nhgxa6?*P25rq8wZE;eBwh z_SIMlRdu&lgmJ}gdzUmatl^Im^zZ^@o6L;W-+i3?_Q=qTU=`WO$dCKUOfpst85LEz z72EcJ8zv9}wU@rX0Z0kiq8c+4!|kOW6w#g$bPwx9rAO`ZGz?L{GoX8>Q~T@1#!8u{ zo4FP4A?kZU-_|MaWf#>cjn}Or00e<%XH5jMS04=zyII@(iPNA40V=C4t4KG@FhT12 zty7n6>GTEnCi7C6C8m@4x0HqwCR2vlR-5Ol_FDYj)PPvAaS zhNV@w)`VKQ;vinEZvO*kzj|FzE9T~p59VdmnzEXP+?$#Y9IYE2lQjPmh4*B*$Xqam z$){b}+s3?kX@P1WI4msf*5STJ=qz=Hqann2Y0v-_qz5MF;Z@Ybu52(l@ z{YZAuvwUsSMwPspND_Ai?uyK-UL55A5?bst;fGvZHlLG$Etm@QhZz9kX4fVW9~l^45C)l+t+FSBbbKpDq3rV9WZ6m*Vn&jCVm zY+BWY&=*0W;`1R4I?sMX8E0eFWN}K6gHpb}^ohWKU-94=#MK!!YyVrCKrLU;qq%F)DOF}9IlB+6dN=hbKQBWD8S(aZ z4vzq&zCJX3QTu+h%Gws!jK}q@zwmy-Gx$q1zwPfPuhNE=kqoIC|3si|xgwAu$A}eD z<;;))*tJKj+mL5k;d~X2nfmiwvr&q2hvsH+M=w)gOO|*$mrHRK~Tw zdE;Igw^RV(ou!k+y(-3*B&`!tiixNy<-M@e5pvR3e_kt%NMt2>w=%Sx3&*(eqV+48Ta) z5n$d7VUigtVlqW~PWomkPn74Zdx#`!m~6fppeC^BkN;`nW5x8G728Hjp~6kY`4SoNY>1LXjG`_1 zfJ(*1GqyC?OGSTtZ&YGe_g@aZ|Lqq3|Mbn%5()v;2Vtc7!FiH|R}x{wdCZis(j#eB zhlKFuhhRE#hVBbOU|#!FhXU1<3hqe_^Y5sdjKd02H+_%pe6@b%-eizl+4r=}>Uv$z zmN;1M7mC5-s80z7N1ks{S5+_&rYte_34~Fw4lb|@t^#}-F+ajr%Ae0@kOYd!7w2{j_Y6wMMM*4V5`rg%1a_C97RKZ64_iXh zV?g>odk1(Hz_nu(?Av8fd8>?M>}ZIDUv2;=`@N(SU5HPuF9?;S^TWvC0IE!cR%<>0 zhp^SN3qo2lzj8oOUw_GVT{rr`Axf7YuD>4>9JSNS3uDE`PjWXTSToxMf0wJdX>x)w{-R_0eBbiYdpLO zhzQ(UmEXT7BGRCrCzGVkC&)=!VeQO&^_+WaG&gD(`>{UA{&^tHrMQtV_kaD@|LJ;9 zMo66lGy1d_U;rkBvWK853c<=s(M5u_a|`RK*eCo|7XYNZwFdzjo>92gVqYW5u$c;F zwFPQm1To7PzbA-b&dwWq6(EFaBDWQzU=Z-Vrkno;*0GyEfNnRf_90ZTSV^O$%Uyyi zw+o%&5`E2wAr&U0f`n3mpfa+v-`@c3_VTm8F#w}_|9Bj3tNv=LMGP5<*@S9t)|1R! z<+!wnMe0+_Gc{G^TdQIU0hANnFMf@BFENo2v2Gtvi;29D^kS=+Oq3|Cn?B$ubUP;nCP?j9GcFm29AU?*S!H=jjN9rTe zA@^Fp3!ahVy*_QRa7?uB(pZX-OiX2=bIY&HSIswM)~3F;2opw}feoT;eqN75RT?*s zRD4dx-3+hdYo)Z`dcMrc{v=b$o$Pev@-D~m*#wE$dvH)wP3@Xz zAbAk(NCacPel8lEjjPN}QdZjsxlE0LzICznMm#cd?~pMbe&d5>AsXEXG9GO=R90%y zK1hgs7Ac<$4?lVdwBj8+fW|^g=SRrV)hzwKsBtEngin0Rei!Za==@bB|1EBy0vg5X z-hXKHJaxViK7hL&j)4C4wk*HGj$Iy;Wq^$G7uTJ1tKDBI$9D-4H2{UEq*vUSPCln$ayOt%ivhrYNRKQ}gN0=+p>x z1C(k`T!u7b!RRsEQp@eZGH#3gX`e3r&m8@9Z51)IYK6jqaD}FoC#@a35QLyUmA7u+ z=3aM|R_R77#T;ml>O_0&SCk!T%+PSEo?{_(?q{vkdK2)S|9I#BO{_69=~H1Q#YHuZ zVw8iskz3qPFw26&&82v(0f7_IU+Gm0MoE_6bf$>9A9Qy?vqAY*)bxs9h45iUevSd> z+J0L4v$c8*(Zi_Q{;{732muQ#NnB+hG-k=>&!a!^<`bk}zK!}r+xZoAukM+EF36plMSGy~9w zwbTQovX`eY2x_sq+|XcaYFty^VU7tlbtxxyy8bik=}>xIt%VIvPV7}1OfE|^8+hY$ z1zbJl;NTee9?9CCB|ZqyNYVND5Cq)W(X822&CtICkcwl5-&)0n)sIE9WHgBps($@o z7CkYcd2k@JK@4M=e{M^-luyr||G`{)Zq541dH+^c@?QoG15dWRw~M|1N-Qf*h>}rS zedr02nSYah*b;(H1vKI0IfAIWcJc}8Od$`;Jz_PE!S+to5_GI$D@U7&P$r8xq=_a^ zHxfL&oNg;b*2tH)+#}+qU9wvEJ&X5`(~x+2D$ccsb6`Q7TIkE+)f@wAgJ!nH(KbgO z($CNPp<`ls0^{7O;{luB7m{}l_2R>a7>YX(j1G;2?;S4zV;rs|Z<$z2ctZT%jG+k0 zOx=3!WS=ysQOKQalu86!*ypc`$I{C=vI%Oj0hx1gG7*D5;nc`_0s_T58}hF4)`4=T(3zE~smfSY{5=g~wc|~O z|8OjL^0-_WF#evi>s{{=Sqqgi3Ykz6Aib%x2ML}(vGHrp&(MXyO^Zvru4e^6B6Cpo zU?^T`Zq#$OkDxrLk!?6BJdCUJbi-S0Wx%l@y^IU+_h=mG88qwPX=i6BpQrvVLIz?6 zYqFLAc*Ijs z|JqE!Q(}AEPjG-)rnn81Q#38#MmYija?D`dl#qG<2y%JqDHlb43izoy`gi0ykNd7p zCz&0b%fl)>aB?yGeo3i*TO)~!p)9?ⅈ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 z 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%0A4~~5kJ9DqgiM(f&+2?BNDroxv43JvTSasSMweF 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