X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=aft.c;h=1d6a5070488ba3beb84a42f37dd0de2d3c0c3789;hp=62db6e7b42bf663af95df97e6764c5ee8891fffc;hb=102a67896e899c9b6a5af43072c81185e6c8dc73;hpb=518a2727540cf5e105d28aa8fd31bb6afad05bf6 diff --git a/aft.c b/aft.c index 62db6e7b..1d6a5070 100644 --- a/aft.c +++ b/aft.c @@ -313,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) @@ -334,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) @@ -351,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]); } @@ -396,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. * @@ -610,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); @@ -647,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; @@ -657,19 +622,21 @@ int load_afd(int shmid, struct audio_file_data *afd) * Mmap the given audio file and update statistics. * * \param aft_row Determines the audio file to be opened and updated. + * \param score The score of the audio file. * \param afd Result pointer. * * On success, the numplayed field of the audio file selector info is increased * 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, long score, + struct audio_file_data *afd) { 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; @@ -680,12 +647,10 @@ int open_and_update_audio_file(struct osl_row *aft_row, struct audio_file_data * 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); @@ -706,37 +671,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; + load_chunk_table(&afd->afhi, chunk_table_obj.data); { struct ls_data d = { .afhi = afd->afhi, - .afsi = afd->afsi, + .afsi = old_afsi, .path = path, - .score = afd->score, + .score = score, .hash = file_hash }; struct para_buffer pb = {.buf = NULL}; ret = make_status_items(&d, &pb); if (ret < 0) goto err; - strncpy(afd->afs_status_info, pb.buf, AFS_STATUS_INFO_SIZE); - afd->afs_status_info[AFS_STATUS_INFO_SIZE - 1] = '\0'; + 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; @@ -787,15 +750,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) @@ -805,8 +774,9 @@ 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; } @@ -816,16 +786,39 @@ static char *make_lyrics_lines(struct afs_info *afsi) char *lyrics_name; lyr_get_name_by_id(afsi->lyrics_id, &lyrics_name); - return make_message("lyrics_id: %u\nlyrics_name: %s\n", - afsi->lyrics_id, lyrics_name? lyrics_name : "(none)"); + 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_lines(struct afs_info *afsi) { char *image_name; img_get_name_by_id(afsi->image_id, &image_name); - return make_message("image_id: %u\nimage_name: %s\n", - afsi->image_id, image_name? image_name : "(none)"); + 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", + status_item_list[SI_BASENAME], path); + 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, @@ -841,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_lines, *image_lines; + char *att_lines, *lyrics_lines, *image_lines, *filename_lines; if (opts->mode == LS_MODE_SHORT) { para_printf(b, "%s\n", d->path); @@ -852,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); @@ -893,86 +886,114 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, att_lines = make_attribute_lines(att_buf, afsi); lyrics_lines = make_lyrics_lines(afsi); image_lines = make_image_lines(afsi); - if (opts->mode == LS_MODE_VERBOSE) { - para_printf(b, - "%s: %s\n" /* path */ - "%s%s%s" /* score */ - "attributes: %s\n" - "hash: %s\n" - "%s" /* image id, image name */ - "%s" /* lyrics */ - "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, - have_score? "\n" : "", - att_lines, - asc_hash, - image_lines, - lyrics_lines, - afhi->bitrate, - audio_format_name(afsi->audio_format_id), - afhi->frequency, - afhi->channels, - duration_buf, - afsi->num_played, - last_played_time, - afhi->info_string - ); - } else { /* mbox mode */ - struct osl_object lyrics_def; - lyr_get_def_by_id(afsi->lyrics_id, &lyrics_def); + filename_lines = make_filename_lines(d->path, opts->flags); + if (opts->mode == LS_MODE_MBOX) para_printf(b, "From foo@localhost %s\n" "Received: from\nTo: bar\nFrom: a\n" - "Subject: %s\n\n" /* path */ - "%s%s%s" /* score */ - "%s\n" /* attributes */ - "hash: %s\n" - "%s\n" /* image id, image name */ - "lyrics_id: %s\n" - "bitrate: %dkbit/s\n" - "format: %s\n" - "frequency: %dHz\n" - "channels: %d\n" - "duration: %s\n" - "num_played: %d\n" - "tag info: %s\n" - "%s%s\n", + "Subject: %s\n\n", last_played_time, - d->path, - have_score? "score: " : "", score_buf, - have_score? "\n" : "", - att_lines, - asc_hash, - image_lines, - lyrics_lines, - afhi->bitrate, - audio_format_name(afsi->audio_format_id), - afhi->frequency, - afhi->channels, - duration_buf, - afsi->num_played, - afhi->info_string, - lyrics_def.data? "Lyrics:\n~~~~~~~\n" : "", - lyrics_def.data? (char *)lyrics_def.data : "" - ); - if (lyrics_def.data) - osl_close_disk_object(lyrics_def.data); + d->path); + para_printf(b, + "%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: %s\n" /* last played time */ + "%s: %d\n" /* num_played */ + "%s" /* tag info */ + "%s: %lu\n" /* chunk time */ + "%s: %lu\n", /* num chunks */ + filename_lines, + have_score? status_item_list[SI_SCORE] : "", + have_score? ": " : "", + score_buf, + have_score? "\n" : "", + att_lines, + 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_LAST_PLAYED], last_played_time, + status_item_list[SI_NUM_PLAYED], afsi->num_played, + afhi->info_string, + status_item_list[SI_CHUNK_TIME], tv2ms(&afhi->chunk_tv), + status_item_list[SI_NUM_CHUNKS], afhi->chunks_total + ); + if (opts->mode == LS_MODE_MBOX) { + struct osl_object lyrics_def; + lyr_get_def_by_id(afsi->lyrics_id, &lyrics_def); + if (lyrics_def.data) { + para_printf(b, "Lyrics:\n~~~~~~~\n%s", + (char *)lyrics_def.data); + osl_close_disk_object(&lyrics_def); + } } free(att_lines); 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 = { @@ -1392,7 +1413,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; @@ -1412,7 +1433,8 @@ 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); + if (afhi) + save_chunk_table(afhi, buf + pos); PARA_DEBUG_LOG("last byte in buf: %p\n", buf + size - 1); obj->data = buf; obj->size = size; @@ -1584,6 +1606,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)); @@ -1591,7 +1614,6 @@ out: return 0; result->data = msg.buf; result->size = msg.size; - afs_event(AUDIO_FILE_ADD, &msg, aft_row); return 1; } @@ -1634,7 +1656,7 @@ static int hash_sister_callback(const struct osl_object *query, static int add_one_audio_file(const char *path, const void *private_data) { - int ret, ret2; + int ret, send_ret = 1; uint8_t format_num = -1; const struct private_add_data *pad = private_data; struct afh_info afhi, *afhi_ptr = NULL; @@ -1659,7 +1681,7 @@ static int add_one_audio_file(const char *path, const void *private_data) ret = 1; if (pb && (pad->flags & ADD_FLAG_LAZY)) { /* lazy is really cheap */ if (pad->flags & ADD_FLAG_VERBOSE) - ret = send_va_buffer(pad->fd, "lazy-ignore: %s\n", path); + send_ret = send_va_buffer(pad->fd, "lazy-ignore: %s\n", path); goto out_free; } /* We still want to add this file. Compute its hash. */ @@ -1668,27 +1690,27 @@ static int add_one_audio_file(const char *path, const void *private_data) goto out_free; hash_function(map.data, map.size, hash); - /* Check whether database contains file with the same hash. */ + /* Check whether the database contains a file with the same hash. */ query.data = hash; query.size = HASH_SIZE; ret = send_callback_request(hash_sister_callback, &query, &result); if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND) - goto out_free; + goto out_unmap; if (ret >= 0) { hs = *(struct osl_row **)result.data; free(result.data); } /* Return success if we already know this file. */ ret = 1; - if (pb && hs && hs == pb && (!(pad->flags & ADD_FLAG_FORCE))) { + if (pb && hs && hs == pb && !(pad->flags & ADD_FLAG_FORCE)) { if (pad->flags & ADD_FLAG_VERBOSE) - ret = send_va_buffer(pad->fd, + send_ret = send_va_buffer(pad->fd, "%s exists, not forcing update\n", path); goto out_unmap; } /* - * we won't recalculate the audio format info and the chunk table if - * there is a hash sister unless in FORCE mode. + * We won't recalculate the audio format info and the chunk table if + * there is a hash sister and FORCE was not given. */ if (!hs || (pad->flags & ADD_FLAG_FORCE)) { ret = compute_afhi(path, map.data, map.size, &afhi); @@ -1697,34 +1719,32 @@ static int add_one_audio_file(const char *path, const void *private_data) format_num = ret; afhi_ptr = &afhi; } + munmap(map.data, map.size); if (pad->flags & ADD_FLAG_VERBOSE) { - ret = send_va_buffer(pad->fd, "adding %s\n", path); - if (ret < 0) - goto out_unmap; + send_ret = send_va_buffer(pad->fd, "adding %s\n", path); + if (send_ret < 0) + goto out_free; } - munmap(map.data, map.size); 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) { - ret2 = send_va_buffer(pad->fd, "%s", (char *)result.data); + send_ret = send_va_buffer(pad->fd, "%s", (char *)result.data); free(result.data); - if (ret >= 0 && ret2 < 0) - ret = ret2; } goto out_free; out_unmap: munmap(map.data, map.size); out_free: - if (ret < 0 && ret != -E_SEND) - send_va_buffer(pad->fd, "failed to add %s (%s)\n", path, + if (ret < 0 && send_ret >= 0) + send_ret = send_va_buffer(pad->fd, "failed to add %s (%s)\n", path, PARA_STRERROR(-ret)); free(obj.data); if (afhi_ptr) free(afhi_ptr->chunk_table); - /* it's not an error if not all files could be added */ - return ret == -E_SEND? ret : 1; + /* Stop adding files only on send errors. */ + return send_ret; } int com_add(int fd, int argc, char * const * const argv)