X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=aft.c;h=df6c2592cd40c7bebcc0969b7292981ddf09a5d0;hp=93c96cb49c8e01bd3e5259e380d413d047f92344;hb=d0381117c7bce410b626bc159ab7763fdb022397;hpb=35726e230f83270ef01000fc57328101a8b0d89f diff --git a/aft.c b/aft.c index 93c96cb4..df6c2592 100644 --- a/aft.c +++ b/aft.c @@ -96,20 +96,6 @@ struct ls_widths { unsigned short num_played_width; }; -/** Data passed to the different compare functions (called by qsort()). */ -struct ls_data { - /** Usual audio format handler information. */ - struct afh_info afhi; - /** Audio file selector information. */ - struct afs_info afsi; - /** The full path of the audio file. */ - char *path; - /** The score value (if -a was given). */ - long score; - /** The sha1 hash of audio file. */ - HASH_TYPE *hash; -}; - /** Data passed from the ls command handler to its callback function. */ struct ls_options { /** The given command line flags. */ @@ -327,14 +313,24 @@ enum afhi_offsets { AFHI_HEADER_OFFSET_OFFSET = 12, /* Length of the audio file header. Zero means: No header. */ AFHI_HEADER_LEN_OFFSET = 16, - /** Number of channels is stored here. */ - AFHI_CHANNELS_OFFSET = 20, - /** EOF timeout in ms. */ - AFHI_EOF_OFFSET = 21, + /** The total number of chunks (4 bytes). */ + CHUNKS_TOTAL_OFFSET = 20, + /** The length of the audio file header (4 bytes). */ + HEADER_LEN_OFFSET = 24, + /** The start of the audio file header (4 bytes). */ + HEADER_OFFSET_OFFSET = 28, + /** The seconds part of the chunk time (4 bytes). */ + CHUNK_TV_TV_SEC_OFFSET = 32, + /** The microseconds part of the chunk time (4 bytes). */ + CHUNK_TV_TV_USEC_OFFSET = 36, + /** Number of channels is stored here. (1 byte) */ + AFHI_CHANNELS_OFFSET = 40, + /** EOF timeout in ms. (2 byte) */ + AFHI_EOF_OFFSET = 41, /** The tag info position. */ - AFHI_INFO_STRING_OFFSET = 23, + AFHI_INFO_STRING_OFFSET = 43, /** Minimal on-disk size of a valid afhi struct. */ - MIN_AFHI_SIZE = 24 + MIN_AFHI_SIZE = 44 }; static unsigned sizeof_afhi_buf(const struct afh_info *afhi) @@ -348,16 +344,19 @@ static void save_afhi(struct afh_info *afhi, char *buf) { if (!afhi) return; - write_u32(buf + AFHI_SECONDS_TOTAL_OFFSET, - afhi->seconds_total); + write_u32(buf + AFHI_SECONDS_TOTAL_OFFSET, afhi->seconds_total); write_u32(buf + AFHI_BITRATE_OFFSET, afhi->bitrate); write_u32(buf + AFHI_FREQUENCY_OFFSET, afhi->frequency); write_u32(buf + AFHI_HEADER_OFFSET_OFFSET, afhi->header_offset); write_u32(buf + AFHI_HEADER_LEN_OFFSET, afhi->header_len); write_u8(buf + AFHI_CHANNELS_OFFSET, afhi->channels); + write_u32(buf + CHUNKS_TOTAL_OFFSET, afhi->chunks_total); + write_u32(buf + HEADER_LEN_OFFSET, afhi->header_len); + write_u32(buf + HEADER_OFFSET_OFFSET, afhi->header_offset); + write_u32(buf + CHUNK_TV_TV_SEC_OFFSET, afhi->chunk_tv.tv_sec); + write_u32(buf + CHUNK_TV_TV_USEC_OFFSET, afhi->chunk_tv.tv_usec); write_u16(buf + AFHI_EOF_OFFSET, tv2ms(&afhi->eof_tv)); strcpy(buf + AFHI_INFO_STRING_OFFSET, afhi->info_string); /* OK */ - PARA_DEBUG_LOG("last byte written: %p\n", buf + AFHI_INFO_STRING_OFFSET + strlen(afhi->info_string)); } static void load_afhi(const char *buf, struct afh_info *afhi) @@ -365,44 +364,29 @@ static void load_afhi(const char *buf, struct afh_info *afhi) afhi->seconds_total = read_u32(buf + AFHI_SECONDS_TOTAL_OFFSET); afhi->bitrate = read_u32(buf + AFHI_BITRATE_OFFSET); afhi->frequency = read_u32(buf + AFHI_FREQUENCY_OFFSET); - afhi->channels = read_u8(buf + AFHI_CHANNELS_OFFSET); afhi->header_offset = read_u32(buf + AFHI_HEADER_OFFSET_OFFSET); afhi->header_len = read_u32(buf + AFHI_HEADER_LEN_OFFSET); + afhi->channels = read_u8(buf + AFHI_CHANNELS_OFFSET); + afhi->chunks_total = read_u32(buf + CHUNKS_TOTAL_OFFSET); + afhi->header_len = read_u32(buf + HEADER_LEN_OFFSET); + afhi->header_offset = read_u32(buf + HEADER_OFFSET_OFFSET); + afhi->chunk_tv.tv_sec = read_u32(buf + CHUNK_TV_TV_SEC_OFFSET); + afhi->chunk_tv.tv_usec = read_u32(buf + CHUNK_TV_TV_USEC_OFFSET); ms2tv(read_u16(buf + AFHI_EOF_OFFSET), &afhi->eof_tv); strcpy(afhi->info_string, buf + AFHI_INFO_STRING_OFFSET); } -//#define SIZEOF_CHUNK_TABLE(afhi) (((afhi)->chunks_total + 1) * sizeof(uint32_t)) - -static unsigned sizeof_chunk_info_buf(struct afh_info *afhi) +static unsigned sizeof_chunk_table(struct afh_info *afhi) { if (!afhi) return 0; - return 4 * (afhi->chunks_total + 1) + 20; - + return 4 * (afhi->chunks_total + 1); } -/** The offsets of the data contained in the AFTCOL_CHUNKS column. */ -enum chunk_info_offsets{ - /** The total number of chunks (4 bytes). */ - CHUNKS_TOTAL_OFFSET = 0, - /** The length of the audio file header (4 bytes). */ - HEADER_LEN_OFFSET = 4, - /** The start of the audio file header (4 bytes). */ - HEADER_OFFSET_OFFSET = 8, - /** The seconds part of the chunk time (4 bytes). */ - CHUNK_TV_TV_SEC_OFFSET = 12, - /** The microseconds part of the chunk time (4 bytes). */ - CHUNK_TV_TV_USEC = 16, - /** Chunk table entries start here. */ - CHUNK_TABLE_OFFSET = 20, -}; - static void save_chunk_table(struct afh_info *afhi, char *buf) { int i; - PARA_DEBUG_LOG("%lu chunks\n", afhi->chunks_total); for (i = 0; i <= afhi->chunks_total; i++) write_u32(buf + 4 * i, afhi->chunk_table[i]); } @@ -410,43 +394,12 @@ static void save_chunk_table(struct afh_info *afhi, char *buf) static void load_chunk_table(struct afh_info *afhi, char *buf) { int i; + + afhi->chunk_table = para_malloc(sizeof_chunk_table(afhi)); for (i = 0; i <= afhi->chunks_total; i++) afhi->chunk_table[i] = read_u32(buf + 4 * i); } -/* TODO: audio format handlers could just produce this */ -static void save_chunk_info(struct afh_info *afhi, char *buf) -{ - if (!afhi) - return; - write_u32(buf + CHUNKS_TOTAL_OFFSET, afhi->chunks_total); - write_u32(buf + HEADER_LEN_OFFSET, afhi->header_len); - write_u32(buf + HEADER_OFFSET_OFFSET, afhi->header_offset); - write_u32(buf + CHUNK_TV_TV_SEC_OFFSET, afhi->chunk_tv.tv_sec); - write_u32(buf + CHUNK_TV_TV_USEC, afhi->chunk_tv.tv_usec); - save_chunk_table(afhi, buf + CHUNK_TABLE_OFFSET); -} - -static int load_chunk_info(struct osl_object *obj, struct afh_info *afhi) -{ - char *buf = obj->data; - - if (obj->size < CHUNK_TABLE_OFFSET) - return -E_BAD_DATA_SIZE; - - afhi->chunks_total = read_u32(buf + CHUNKS_TOTAL_OFFSET); - afhi->header_len = read_u32(buf + HEADER_LEN_OFFSET); - afhi->header_offset = read_u32(buf + HEADER_OFFSET_OFFSET); - afhi->chunk_tv.tv_sec = read_u32(buf + CHUNK_TV_TV_SEC_OFFSET); - afhi->chunk_tv.tv_usec = read_u32(buf + CHUNK_TV_TV_USEC); - - if ((afhi->chunks_total + 1) * 4 + CHUNK_TABLE_OFFSET > obj->size) - return -E_BAD_DATA_SIZE; - afhi->chunk_table = para_malloc((afhi->chunks_total + 1) * 4); - load_chunk_table(afhi, buf + CHUNK_TABLE_OFFSET); - return 1; -} - /** * Get the row of the audio file table corresponding to the given path. * @@ -624,8 +577,7 @@ int get_afhi_of_row(const struct osl_row *row, struct afh_info *afhi) /* returns shmid on success */ static int save_afd(struct audio_file_data *afd) { - size_t size = sizeof(*afd) - + 4 * (afd->afhi.chunks_total + 1); + size_t size = sizeof(*afd) + sizeof_chunk_table(&afd->afhi); PARA_DEBUG_LOG("size: %zu\n", size); int shmid, ret = shm_new(size); @@ -661,7 +613,6 @@ int load_afd(int shmid, struct audio_file_data *afd) *afd = *(struct audio_file_data *)shm_afd; buf = shm_afd; buf += sizeof(*afd); - afd->afhi.chunk_table = para_malloc((afd->afhi.chunks_total + 1) * 4); load_chunk_table(&afd->afhi, buf); shm_detach(shm_afd); return 1; @@ -677,29 +628,28 @@ int load_afd(int shmid, struct audio_file_data *afd) * and the lastplayed time is set to the current time. Finally, the score of * the audio file is updated. * - * \return Positive on success, negative on errors. + * \return Positive shmid on success, negative on errors. */ -int open_and_update_audio_file(struct osl_row *aft_row, struct audio_file_data *afd) +int open_and_update_audio_file(struct osl_row *aft_row, + struct audio_file_data *afd, long score) { HASH_TYPE *aft_hash, file_hash[HASH_SIZE]; struct osl_object afsi_obj; - struct afs_info new_afsi; + struct afs_info old_afsi, new_afsi; int ret = get_hash_of_row(aft_row, &aft_hash); struct afsi_change_event_data aced; struct osl_object map, chunk_table_obj; - char *tmp, *path; + char *path; if (ret < 0) return ret; ret = get_audio_file_path_of_row(aft_row, &path); if (ret < 0) return ret; - strncpy(afd->path, path, sizeof(afd->path) - 1); - afd->path[sizeof(afd->path) - 1] = '\0'; ret = get_afsi_object_of_row(aft_row, &afsi_obj); if (ret < 0) return ret; - ret = load_afsi(&afd->afsi, &afsi_obj); + ret = load_afsi(&old_afsi, &afsi_obj); if (ret < 0) return ret; ret = get_afhi_of_row(aft_row, &afd->afhi); @@ -720,29 +670,35 @@ int open_and_update_audio_file(struct osl_row *aft_row, struct audio_file_data * ret = -E_HASH_MISMATCH; goto err; } - new_afsi = afd->afsi; + new_afsi = old_afsi; new_afsi.num_played++; new_afsi.last_played = time(NULL); save_afsi(&new_afsi, &afsi_obj); /* in-place update */ - ret = load_chunk_info(&chunk_table_obj, &afd->afhi); - if (ret < 0) - goto err; - ret = get_attribute_text(&afd->afsi.attributes, " ", &tmp); - if (ret < 0) - goto err; - assert(tmp); - strncpy(afd->attributes_string, tmp, sizeof(afd->attributes_string)); - afd->attributes_string[sizeof(afd->attributes_string) - 1] = '\0'; - free(tmp); - + load_chunk_table(&afd->afhi, chunk_table_obj.data); + { + struct ls_data d = { + .afhi = afd->afhi, + .afsi = old_afsi, + .path = path, + .score = score, + .hash = file_hash + }; + struct para_buffer pb = {.buf = NULL}; + ret = make_status_items(&d, &pb); + if (ret < 0) + goto err; + strncpy(afd->verbose_ls_output, pb.buf, VERBOSE_LS_OUTPUT_SIZE); + afd->verbose_ls_output[VERBOSE_LS_OUTPUT_SIZE - 1] = '\0'; + free(pb.buf); + } aced.aft_row = aft_row; - aced.old_afsi = &afd->afsi; + aced.old_afsi = &old_afsi; afs_event(AFSI_CHANGE, NULL, &aced); ret = save_afd(afd); + free(afd->afhi.chunk_table); if (ret < 0) goto err; - free(afd->afhi.chunk_table); err: osl_close_disk_object(&chunk_table_obj); return ret; @@ -793,15 +749,21 @@ static short unsigned get_duration_width(int seconds) return width + 6; } -static void get_duration_buf(int seconds, char *buf, short unsigned max_width) +static void get_duration_buf(int seconds, char *buf, struct ls_options *opts) { unsigned hours = seconds / 3600, mins = (seconds % 3600) / 60; + short unsigned max_width; - if (!hours) /* m:ss or mm:ss */ + if (!hours) { /* m:ss or mm:ss */ + max_width = opts->mode == LS_MODE_LONG? + opts->widths.duration_width : 4; sprintf(buf, "%*u:%02u", max_width - 3, mins, seconds % 60); - else /* more than one hour => h:mm:ss, hh:mm:ss, hhh:mm:ss, ... */ + } else { /* more than one hour => h:mm:ss, hh:mm:ss, hhh:mm:ss, ... */ + max_width = opts->mode == LS_MODE_LONG? + opts->widths.duration_width : 7; sprintf(buf, "%*u:%02u:%02u", max_width - 6, hours, mins, seconds % 60); + } } static char *make_attribute_lines(const char *att_bitmap, struct afs_info *afsi) @@ -811,29 +773,52 @@ static char *make_attribute_lines(const char *att_bitmap, struct afs_info *afsi) get_attribute_text(&afsi->attributes, " ", &att_text); if (!att_text) return para_strdup(att_bitmap); - att_lines = make_message("%s\nattributes_txt: %s", - att_bitmap, att_text); + att_lines = make_message("%s: %s\n%s: %s", + status_item_list[SI_ATTRIBUTES_BITMAP], att_bitmap, + status_item_list[SI_ATTRIBUTES_TXT], att_text); free(att_text); return att_lines; } -static char *make_lyrics_line(struct afs_info *afsi) +static char *make_lyrics_lines(struct afs_info *afsi) { char *lyrics_name; lyr_get_name_by_id(afsi->lyrics_id, &lyrics_name); - if (!lyrics_name) - return make_message("%u", afsi->lyrics_id); - return make_message("%u (%s)", afsi->lyrics_id, lyrics_name); + return make_message("%s: %u\n%s: %s\n", + status_item_list[SI_LYRICS_ID], afsi->lyrics_id, + status_item_list[SI_LYRICS_NAME], lyrics_name? + lyrics_name : "(none)"); } -static char *make_image_line(struct afs_info *afsi) +static char *make_image_lines(struct afs_info *afsi) { char *image_name; img_get_name_by_id(afsi->image_id, &image_name); - if (!image_name) - return make_message("%u", afsi->image_id); - return make_message("%u (%s)", afsi->image_id, image_name); + return make_message("%s: %u\n%s: %s\n", + status_item_list[SI_IMAGE_ID], afsi->image_id, + status_item_list[SI_IMAGE_NAME], image_name? + image_name : "(none)"); +} + +static char *make_filename_lines(const char *path, unsigned flags) +{ + char *basename, *dirname; + char *ret; + + if (!(flags & LS_FLAG_FULL_PATH)) + return make_message("%s: %s\n%s:\n", + status_item_list[SI_BASENAME], path, + status_item_list[SI_DIRECTORY]); + basename = para_basename(path), + dirname = para_dirname(path); + ret = make_message("%s: %s\n%s: %s\n%s: %s\n", + status_item_list[SI_PATH], path, + status_item_list[SI_DIRECTORY], dirname, + status_item_list[SI_BASENAME], basename); + free(basename); + free(dirname); + return ret; } static int print_list_item(struct ls_data *d, struct ls_options *opts, @@ -849,7 +834,7 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, struct ls_widths *w = &opts->widths; int have_score = opts->flags & LS_FLAG_ADMISSIBLE_ONLY; char asc_hash[2 * HASH_SIZE + 1]; - char *att_lines, *lyrics_line, *image_line; + char *att_lines, *lyrics_lines, *image_lines, *filename_lines; if (opts->mode == LS_MODE_SHORT) { para_printf(b, "%s\n", d->path); @@ -860,7 +845,7 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, sizeof(last_played_time), current_time, opts->mode); if (ret < 0) return ret; - get_duration_buf(afhi->seconds_total, duration_buf, w->duration_width); + get_duration_buf(afhi->seconds_total, duration_buf, opts); if (have_score) { if (opts->mode == LS_MODE_LONG) sprintf(score_buf, "%*li ", w->score_width, d->score); @@ -899,43 +884,46 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, } hash_to_asc(d->hash, asc_hash); att_lines = make_attribute_lines(att_buf, afsi); - lyrics_line = make_lyrics_line(afsi); - image_line = make_image_line(afsi); - /* TODO: Merge this with status items */ + lyrics_lines = make_lyrics_lines(afsi); + image_lines = make_image_lines(afsi); + filename_lines = make_filename_lines(d->path, opts->flags); if (opts->mode == LS_MODE_VERBOSE) { para_printf(b, - "%s: %s\n" /* path */ - "%s%s%s" /* score */ - "attributes: %s\n" - "hash: %s\n" - "image_id: %s\n" - "lyrics_id: %s\n" - "bitrate: %dkbit/s\n" - "format: %s\n" - "frequency: %dHz\n" - "channels: %d\n" - "duration: %s\n" - "num_played: %d\n" - "last_played: %s\n" - "tag info: %s\n", - (opts->flags & LS_FLAG_FULL_PATH)? - "path" : "file", d->path, - have_score? "score: " : "", score_buf, + "%s" /* filename stuff */ + "%s%s%s%s" /* score */ + "%s\n" /* attributes */ + "%s: %s\n" /* hash */ + "%s" /* image id, image name */ + "%s" /* lyrics */ + "%s: %dkbit/s\n" /* bitrate */ + "%s: %s\n" /* format */ + "%s: %dHz\n" /* frequency */ + "%s: %d\n" /* channels */ + "%s: %s\n" /* duration */ + "%s: %lu\n" /* seconds total */ + "%s: %d\n" /* num_played */ + "%s: %s\n" /* last_played */ + "%s", /* tag info */ + filename_lines, + have_score? status_item_list[SI_SCORE] : "", + have_score? ": " : "", + score_buf, have_score? "\n" : "", att_lines, - asc_hash, - image_line, - lyrics_line, - afhi->bitrate, - audio_format_name(afsi->audio_format_id), - afhi->frequency, - afhi->channels, - duration_buf, - afsi->num_played, - last_played_time, + status_item_list[SI_HASH], asc_hash, + image_lines, + lyrics_lines, + status_item_list[SI_BITRATE], afhi->bitrate, + status_item_list[SI_FORMAT], audio_format_name(afsi->audio_format_id), + status_item_list[SI_FREQUENCY], afhi->frequency, + status_item_list[SI_CHANNELS], afhi->channels, + status_item_list[SI_DURATION], duration_buf, + status_item_list[SI_SECONDS_TOTAL], afhi->seconds_total, + status_item_list[SI_NUM_PLAYED], afsi->num_played, + status_item_list[SI_LAST_PLAYED], last_played_time, afhi->info_string ); - } else { /* mbox mode */ + } else { /* mbox mode */ /* FIXME: merge with verbose output */ struct osl_object lyrics_def; lyr_get_def_by_id(afsi->lyrics_id, &lyrics_def); para_printf(b, @@ -945,7 +933,7 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, "%s%s%s" /* score */ "%s\n" /* attributes */ "hash: %s\n" - "image_id: %s\n" + "%s\n" /* image id, image name */ "lyrics_id: %s\n" "bitrate: %dkbit/s\n" "format: %s\n" @@ -953,7 +941,7 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, "channels: %d\n" "duration: %s\n" "num_played: %d\n" - "tag info: %s\n" + "%s\n" /* tag info */ "%s%s\n", last_played_time, d->path, @@ -961,8 +949,8 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, have_score? "\n" : "", att_lines, asc_hash, - image_line, - lyrics_line, + image_lines, + lyrics_lines, afhi->bitrate, audio_format_name(afsi->audio_format_id), afhi->frequency, @@ -977,11 +965,70 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, osl_close_disk_object(lyrics_def.data); } free(att_lines); - free(lyrics_line); - free(image_line); + free(lyrics_lines); + free(image_lines); + free(filename_lines); return 1; } +void make_empty_status_items(char *buf) +{ + sprintf(buf, + "%s: \n" /* path */ + "%s: \n" /* dirname */ + "%s: \n" /* basename */ + "%s: \n" /* score */ + "%s: \n" /* attributes bitnmap */ + "%s: \n" /* attributes txt */ + "%s: \n" /* hash */ + "%s: \n" /* image id */ + "%s: \n" /* image name */ + "%s: \n" /* lyrics id */ + "%s: \n" /* lyrics name */ + "%s: \n" /* bitrate */ + "%s: \n" /* format */ + "%s: \n" /* frequency */ + "%s: \n" /* channels */ + "%s: \n" /* duration */ + "%s: \n" /* seconds total */ + "%s: \n" /* num played */ + "%s: \n" /* last played */ + , + status_item_list[SI_PATH], + status_item_list[SI_DIRECTORY], + status_item_list[SI_BASENAME], + status_item_list[SI_SCORE], + status_item_list[SI_ATTRIBUTES_BITMAP], + status_item_list[SI_ATTRIBUTES_TXT], + status_item_list[SI_HASH], + status_item_list[SI_IMAGE_ID], + status_item_list[SI_IMAGE_NAME], + status_item_list[SI_LYRICS_ID], + status_item_list[SI_LYRICS_NAME], + status_item_list[SI_BITRATE], + status_item_list[SI_FORMAT], + status_item_list[SI_FREQUENCY], + status_item_list[SI_CHANNELS], + status_item_list[SI_DURATION], + status_item_list[SI_SECONDS_TOTAL], + status_item_list[SI_NUM_PLAYED], + status_item_list[SI_LAST_PLAYED] + ); +} + +int make_status_items(struct ls_data *d, struct para_buffer *pb) +{ + struct ls_options opts = { + .flags = LS_FLAG_FULL_PATH | LS_FLAG_ADMISSIBLE_ONLY, + .mode = LS_MODE_VERBOSE, + }; + time_t current_time; + + time(¤t_time); + return print_list_item(d, &opts, pb, current_time); +} + + static int ls_audio_format_compare(const void *a, const void *b) { struct ls_data *d1 = *(struct ls_data **)a, *d2 = *(struct ls_data **)b; @@ -1388,7 +1435,7 @@ static void save_audio_file_info(HASH_TYPE *hash, const char *path, size_t path_len = strlen(path) + 1; size_t afhi_size = sizeof_afhi_buf(afhi); size_t size = AFTROW_PATH_OFFSET + path_len + afhi_size - + sizeof_chunk_info_buf(afhi); + + sizeof_chunk_table(afhi); char *buf = para_malloc(size); uint16_t pos; @@ -1408,7 +1455,7 @@ static void save_audio_file_info(HASH_TYPE *hash, const char *path, pos += afhi_size; PARA_DEBUG_LOG("size: %zu, chunks start at %d\n", size, pos); write_u16(buf + AFTROW_CHUNKS_OFFSET_POS, pos); - save_chunk_info(afhi, buf + pos); + save_chunk_table(afhi, buf + pos); PARA_DEBUG_LOG("last byte in buf: %p\n", buf + size - 1); obj->data = buf; obj->size = size; @@ -1580,6 +1627,7 @@ static int com_add_callback(const struct osl_object *query, objs[AFTCOL_AFSI].size = AFSI_SIZE; save_afsi(&default_afsi, &objs[AFTCOL_AFSI]); ret = osl_add_and_get_row(audio_file_table, objs, &aft_row); + afs_event(AUDIO_FILE_ADD, &msg, aft_row); out: if (ret < 0) para_printf(&msg, "%s\n", PARA_STRERROR(-ret)); @@ -1587,7 +1635,6 @@ out: return 0; result->data = msg.buf; result->size = msg.size; - afs_event(AUDIO_FILE_ADD, &msg, aft_row); return 1; } @@ -1702,7 +1749,7 @@ static int add_one_audio_file(const char *path, const void *private_data) save_audio_file_info(hash, path, afhi_ptr, pad->flags, format_num, &obj); /* Ask afs to consider this entry for adding. */ ret = send_callback_request(com_add_callback, &obj, &result); - if (ret >= 0 && result.data && result.size) { + if (ret > 0) { ret2 = send_va_buffer(pad->fd, "%s", (char *)result.data); free(result.data); if (ret >= 0 && ret2 < 0)