X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=afh_common.c;h=a1021ee57a2fd67f0192a8049cfa512ecd5629d3;hp=063ae8f0b104ccab15e9f10f637ec34e7783e785;hb=b6b571e6c6fb52207b11fc7833b272ec8cfa28bf;hpb=75695bba841fc43094ebc669418187080cea00e6

diff --git a/afh_common.c b/afh_common.c
index 063ae8f0..a1021ee5 100644
--- a/afh_common.c
+++ b/afh_common.c
@@ -109,6 +109,11 @@ void afh_init(void)
 	}
 }
 
+static bool afh_supports_dynamic_chunks(int audio_format_id)
+{
+	return afl[audio_format_id].get_chunk;
+}
+
 /**
  * Guess the audio format judging from filename.
  *
@@ -139,6 +144,38 @@ int guess_audio_format(const char *name)
 	return -E_AUDIO_FORMAT;
 }
 
+/**
+ * Get the name of the given audio format.
+ *
+ * \param i The audio format number.
+ *
+ * \return This returns a pointer to statically allocated memory so it
+ * must not be freed by the caller.
+ */
+const char *audio_format_name(int i)
+{
+	if (i < 0 || i >= ARRAY_SIZE(afl) - 1)
+		return "???";
+	return afl[i].name;
+}
+
+static int get_file_info(int format, const char *path, char *data,
+		size_t size, int fd, struct afh_info *afhi)
+{
+	int ret;
+	const char *fmt = audio_format_name(format);
+
+	memset(afhi, 0, sizeof(*afhi));
+	ret = afl[format].get_file_info(data, size, fd, afhi);
+	if (ret < 0) {
+		PARA_WARNING_LOG("%s: %s format not detected: %s\n",
+			path, fmt, para_strerror(-ret));
+		return ret;
+	}
+	PARA_NOTICE_LOG("%s: detected %s format\n", path, fmt);
+	return format;
+}
+
 /**
  * Call get_file_info() to obtain an afhi structure.
  *
@@ -163,31 +200,18 @@ int compute_afhi(const char *path, char *data, size_t size, int fd,
 {
 	int ret, i, format;
 
-	afhi->header_len = 0;
-	afhi->techinfo = NULL;
-	afhi->tags.artist = NULL;
-	afhi->tags.title = NULL;
-	afhi->tags.year = NULL;
-	afhi->tags.album = NULL;
-	afhi->tags.comment = NULL;
 	format = guess_audio_format(path);
-
 	if (format >= 0) {
-		ret = afl[format].get_file_info(data, size, fd, afhi);
-		if (ret >= 0) {
-			ret = format;
+		ret = get_file_info(format, path, data, size, fd, afhi);
+		if (ret >= 0)
 			goto success;
-		}
 	}
 	FOR_EACH_AUDIO_FORMAT(i) {
 		if (i == format) /* we already tried this one to no avail */
 			continue;
-		ret = afl[i].get_file_info(data, size, fd, afhi);
-		if (ret >= 0) {
-			ret = i;
+		ret = get_file_info(i, path, data, size, fd, afhi);
+		if (ret >= 0)
 			goto success;
-		}
-		PARA_WARNING_LOG("%s\n", para_strerror(-ret));
 	}
 	return -E_AUDIO_FORMAT;
 success:
@@ -233,21 +257,6 @@ void clear_afhi(struct afh_info *afhi)
 	free(afhi->tags.comment);
 }
 
-/**
- * Get the name of the given audio format.
- *
- * \param i The audio format number.
- *
- * \return This returns a pointer to statically allocated memory so it
- * must not be freed by the caller.
- */
-const char *audio_format_name(int i)
-{
-	if (i < 0 || i >= ARRAY_SIZE(afl) - 1)
-		return "???";
-	return afl[i].name;
-}
-
 static inline size_t get_chunk_len(long unsigned chunk_num,
 		const struct afh_info *afhi)
 {
@@ -257,21 +266,73 @@ static inline size_t get_chunk_len(long unsigned chunk_num,
 /**
  * Get one chunk of audio data.
  *
+ * This implicitly calls the ->open method of the audio format handler at the
+ * first call.
+ *
  * \param chunk_num The number of the chunk to get.
  * \param afhi Describes the audio file.
+ * \param audio_format_id Determines the afh.
  * \param map The memory mapped audio file.
+ * \param mapsize Passed to the afh's ->open() method.
  * \param buf Result pointer.
  * \param len The length of the chunk in bytes.
+ * \param afh_context Value/result, determines whether ->open() is called.
  *
  * Upon return, \a buf will point so memory inside \a map. The returned buffer
  * must therefore not be freed by the caller.
+ *
+ * \return Standard.
  */
-void afh_get_chunk(long unsigned chunk_num, struct afh_info *afhi,
-		void *map, const char **buf, size_t *len)
+__must_check int afh_get_chunk(long unsigned chunk_num, struct afh_info *afhi,
+		uint8_t audio_format_id, const void *map, size_t mapsize,
+		const char **buf, size_t *len, void **afh_context)
 {
-	size_t pos = afhi->chunk_table[chunk_num];
-	*buf = map + pos;
-	*len = get_chunk_len(chunk_num, afhi);
+	struct audio_format_handler *afh = afl + audio_format_id;
+
+	if (afh_supports_dynamic_chunks(audio_format_id)) {
+		int ret;
+
+		if (!*afh_context) {
+			ret = afh->open(map, mapsize, afh_context);
+			if (ret < 0)
+				return ret;
+		}
+		ret = afl[audio_format_id].get_chunk(chunk_num, *afh_context,
+			buf, len);
+		if (ret < 0) {
+			afh->close(*afh_context);
+			*afh_context = NULL;
+		}
+		return ret;
+	} else {
+		size_t pos = afhi->chunk_table[chunk_num];
+		*buf = map + pos;
+		*len = get_chunk_len(chunk_num, afhi);
+		return 0;
+	}
+}
+
+/**
+ * Deallocate resources allocated due to dynamic chunk handling.
+ *
+ * This function should be called if afh_get_chunk() was called at least once.
+ * It is OK to call it even for audio formats which do not support dynamic
+ * chunks, in which case the function does nothing.
+ *
+ * \param afh_context As returned from the ->open method of the afh.
+ * \param audio_format_id Determines the afh.
+ */
+void afh_close(void *afh_context, uint8_t audio_format_id)
+{
+	struct audio_format_handler *afh = afl + audio_format_id;
+
+	if (!afh_supports_dynamic_chunks(audio_format_id))
+		return;
+	if (!afh->close)
+		return;
+	if (!afh_context)
+		return;
+	afh->close(afh_context);
 }
 
 /**
@@ -279,20 +340,26 @@ void afh_get_chunk(long unsigned chunk_num, struct afh_info *afhi,
  *
  * \param approx_chunk_num Upper bound for the chunk number to return.
  * \param afhi Needed for the chunk table.
+ * \param audio_format_id Determines the afh.
  *
- * \return The first non-empty chunk <= \a approx_chunk_num.
+ * \return For audio format handlers which support dynamic chunks, the function
+ * returns the given chunk number. Otherwise it returns the first non-empty
+ * chunk <= \a approx_chunk_num.
  *
  * \sa \ref afh_get_chunk().
  */
 int32_t afh_get_start_chunk(int32_t approx_chunk_num,
-		const struct afh_info *afhi)
+		const struct afh_info *afhi, uint8_t audio_format_id)
 {
 	int32_t k;
 
+	if (afh_supports_dynamic_chunks(audio_format_id))
+		return approx_chunk_num;
+
 	for (k = PARA_MAX(0, approx_chunk_num); k >= 0; k--)
 		if (get_chunk_len(k, afhi) > 0)
-			break;
-	return k;
+			return k;
+	return 0;
 }
 
 /**
@@ -370,6 +437,7 @@ unsigned afh_get_afhi_txt(int audio_format_num, struct afh_info *afhi, char **re
 		"%s: %" PRIu32 "\n" /* seconds total */
 		"%s: %lu: %lu\n" /* chunk time */
 		"%s: %" PRIu32 "\n" /* num chunks */
+		"%s: %" PRIu32 "\n" /* max chunk size */
 		"%s: %s\n" /* techinfo */
 		"%s: %s\n" /* artist */
 		"%s: %s\n" /* title */
@@ -384,6 +452,7 @@ unsigned afh_get_afhi_txt(int audio_format_num, struct afh_info *afhi, char **re
 		status_item_list[SI_CHUNK_TIME], (long unsigned)afhi->chunk_tv.tv_sec,
 			(long unsigned)afhi->chunk_tv.tv_usec,
 		status_item_list[SI_NUM_CHUNKS], afhi->chunks_total,
+		status_item_list[SI_MAX_CHUNK_SIZE], afhi->max_chunk_size,
 		status_item_list[SI_TECHINFO], afhi->techinfo? afhi->techinfo : "",
 		status_item_list[SI_ARTIST], afhi->tags.artist? afhi->tags.artist : "",
 		status_item_list[SI_TITLE], afhi->tags.title? afhi->tags.title : "",
@@ -393,6 +462,37 @@ unsigned afh_get_afhi_txt(int audio_format_num, struct afh_info *afhi, char **re
 	);
 }
 
+/**
+ * Determine the maximal chunk size by investigating the chunk table.
+ *
+ * \param afhi Value/result.
+ *
+ * This function iterates over the chunk table and sets ->max_chunk_size
+ * accordingly. The function exists only for backward compatibility since as of
+ * version 0.6.0, para_server stores the maximal chunk size in its database.
+ * This function is only called if the database value is zero, indicating that
+ * the file was added by an older server version.
+ */
+void set_max_chunk_size(struct afh_info *afhi)
+{
+	uint32_t n, max = 0, old = 0;
+
+	for (n = 0; n <= afhi->chunks_total; n++) {
+		uint32_t val = afhi->chunk_table[n];
+		/*
+		 * If the first chunk is the header, do not consider it for the
+		 * calculation of the largest chunk size.
+		 */
+		if (n == 0 || (n == 1 && afhi->header_len > 0)) {
+			old = val;
+			continue;
+		}
+		max = PARA_MAX(max, val - old);
+		old = val;
+	}
+	afhi->max_chunk_size = max;
+}
+
 /**
  * Create a copy of the given file with altered meta tags.
  *