X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=aft.c;h=0efd285c2eb716df2aeeb47e4dfd06aa1d293e5f;hp=133fe672f1f576b2a5ce10e66c665dc8a91c8250;hb=7ab176a3b0771cfcdd8ee103cd5452e971d12e26;hpb=045273c289eb3d972eea99df99967f680b06940f diff --git a/aft.c b/aft.c index 133fe672..0efd285c 100644 --- a/aft.c +++ b/aft.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007 Andre Noll + * Copyright (C) 2007-2008 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -58,7 +58,9 @@ enum ls_listing_mode { /** -lv */ LS_MODE_VERBOSE, /** -lm */ - LS_MODE_MBOX + LS_MODE_MBOX, + /** -lc */ + LS_MODE_CHUNKS }; /** The flags accepted by the ls command. */ @@ -313,14 +315,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 +346,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 +366,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 +396,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 +579,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 +615,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 +624,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 +649,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); @@ -695,6 +662,7 @@ int open_and_update_audio_file(struct osl_row *aft_row, struct audio_file_data * AFTCOL_CHUNKS, &chunk_table_obj); if (ret < 0) return ret; + afd->afhi.chunk_table = NULL; ret = mmap_full_file(path, O_RDONLY, &map.data, &map.size, &afd->fd); if (ret < 0) @@ -706,38 +674,34 @@ 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] = '\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); - if (ret < 0) - goto err; - free(afd->afhi.chunk_table); err: + free(afd->afhi.chunk_table); osl_close_disk_object(&chunk_table_obj); return ret; } @@ -787,15 +751,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,29 +775,79 @@ 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 *dirname, *ret; + const char *basename; + + 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? dirname : "?", + status_item_list[SI_BASENAME], basename? basename : "?"); + free(dirname); + return ret; +} + +static int print_chunk_table(struct ls_data *d, struct para_buffer *b) +{ + struct osl_object chunk_table_obj; + struct osl_row *aft_row; + int ret, i; + char *buf; + + ret = aft_get_row_of_hash(d->hash, &aft_row); + if (ret < 0) + return ret; + ret = osl_open_disk_object(audio_file_table, aft_row, + AFTCOL_CHUNKS, &chunk_table_obj); + if (ret < 0) + return ret; + buf = chunk_table_obj.data; + para_printf(b, "%s\n" + "chunk_time: %lu:%lu\nchunk_offsets: ", + d->path, + (long unsigned) d->afhi.chunk_tv.tv_sec, + (long unsigned) d->afhi.chunk_tv.tv_usec + ); + for (i = 0; i <= d->afhi.chunks_total; i++) + para_printf(b, "%u ", + (unsigned) read_u32(buf + 4 * i)); + osl_close_disk_object(&chunk_table_obj); + para_printf(b, "\n"); + return 1; } static int print_list_item(struct ls_data *d, struct ls_options *opts, @@ -843,18 +863,20 @@ 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); return 1; } + if (opts->mode == LS_MODE_CHUNKS) + return print_chunk_table(d, b); get_attribute_bitmap(&afsi->attributes, att_buf); ret = get_local_time(&afsi->last_played, last_played_time, 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,88 +915,118 @@ 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); - 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, - 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, - afhi->info_string - ); - } else { /* mbox mode */ - struct osl_object lyrics_def; - lyr_get_def_by_id(afsi->lyrics_id, &lyrics_def); + 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_MBOX) { + const char *bn = para_basename(d->path); 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" - "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" - "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_line, - lyrics_line, - 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); + bn? bn : "?"); + } + 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_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 bitmap */ + "%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 = { @@ -1280,6 +1332,9 @@ int com_ls(int fd, int argc, char * const * const argv) case 'm': mode = LS_MODE_MBOX; continue; + case 'c': + mode = LS_MODE_CHUNKS; + continue; default: return -E_AFT_SYNTAX; } @@ -1376,88 +1431,111 @@ static struct osl_row *find_hash_sister(HASH_TYPE *hash) return row; } -enum aft_row_offsets { - AFTROW_AFHI_OFFSET_POS = 0, - AFTROW_CHUNKS_OFFSET_POS = 2, - AFTROW_AUDIO_FORMAT_OFFSET = 4, - AFTROW_FLAGS_OFFSET = 5, - AFTROW_HASH_OFFSET = 9, - AFTROW_PATH_OFFSET = (AFTROW_HASH_OFFSET + HASH_SIZE), +/** The format of the data stored by save_audio_file_data(). */ +enum com_add_buffer_offsets { + /** afhi (if present) starts here. */ + CAB_AFHI_OFFSET_POS = 0, + /** Start of the chunk table (if present). */ + CAB_CHUNKS_OFFSET_POS = 2, + /** Audio format id. */ + CAB_AUDIO_FORMAT_OFFSET = 4, + /** Flags given to the add command. */ + CAB_FLAGS_OFFSET = 5, + /** The hash of the audio file being added. */ + CAB_HASH_OFFSET = 9, + /** Start of the path of the audio file. */ + CAB_PATH_OFFSET = (CAB_HASH_OFFSET + HASH_SIZE), }; -/* never save the afsi, as the server knows it too. Note that afhi might be NULL. - * In this case, afhi won't be stored in the buffer */ -static void save_audio_file_info(HASH_TYPE *hash, const char *path, +/* + * Store the given data to a single buffer. Doesn't need the audio file selector + * info struct as the server knows it as well. + * + * It's OK to call this with afhi == NULL. In this case, the audio format + * handler info won't be stored in the buffer. + */ +static void save_add_callback_buffer(HASH_TYPE *hash, const char *path, struct afh_info *afhi, uint32_t flags, uint8_t audio_format_num, struct osl_object *obj) { 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); + size_t size = CAB_PATH_OFFSET + path_len + afhi_size + + sizeof_chunk_table(afhi); char *buf = para_malloc(size); uint16_t pos; - write_u8(buf + AFTROW_AUDIO_FORMAT_OFFSET, audio_format_num); - write_u32(buf + AFTROW_FLAGS_OFFSET, flags); + write_u8(buf + CAB_AUDIO_FORMAT_OFFSET, audio_format_num); + write_u32(buf + CAB_FLAGS_OFFSET, flags); - memcpy(buf + AFTROW_HASH_OFFSET, hash, HASH_SIZE); - strcpy(buf + AFTROW_PATH_OFFSET, path); + memcpy(buf + CAB_HASH_OFFSET, hash, HASH_SIZE); + strcpy(buf + CAB_PATH_OFFSET, path); - pos = AFTROW_PATH_OFFSET + path_len; + pos = CAB_PATH_OFFSET + path_len; PARA_DEBUG_LOG("size: %zu, afhi starts at %d\n", size, pos); PARA_DEBUG_LOG("last afhi byte: %p, pos %zu\n", buf + pos + afhi_size - 1, pos + afhi_size - 1); - write_u16(buf + AFTROW_AFHI_OFFSET_POS, pos); + write_u16(buf + CAB_AFHI_OFFSET_POS, pos); save_afhi(afhi, buf + pos); 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); + write_u16(buf + CAB_CHUNKS_OFFSET_POS, 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; } /* -input: + +Overview of the add command. + +Input: What was passed to the callback by the command handler. ~~~~~~ -HS: hash sister -PB: path brother -F: force flag given +HS: Hash sister. Whether an audio file with identical hash + already exists in the osl database. + +PB: Path brother. Whether a file with the given path exists + in the table. + +F: Force flag given. Whether add was called with -f. -output: +output: Action performed by the callback. ~~~~~~~ -AFHI: whether afhi and chunk table are computed and sent -ACTION: table modifications to be performed - -+---+----+-----+------+---------------------------------------------------+ -| HS | PB | F | AFHI | ACTION -+---+----+-----+------+---------------------------------------------------+ -| Y | Y | Y | Y | if HS != PB: remove PB. HS: force afhi update, -| | update path, keep afsi -+---+----+-----+------+---------------------------------------------------+ -| Y | Y | N | N | if HS == PB: do not send callback request at all. -| | otherwise: remove PB, HS: update path, keep afhi, -| | afsi. -+---+----+-----+------+---------------------------------------------------+ -| Y | N | Y | Y | (rename) force afhi update of HS, update path of -| | HS, keep afsi -+---+----+-----+------+---------------------------------------------------+ -| Y | N | N | N | (file rename) update path of HS, keep afsi, afhi -+---+----+-----+------+---------------------------------------------------+ -| N | Y | Y | Y | (file change) update afhi, hash, of PB, keep afsi -| | (force has no effect) -+---+----+-----+------+---------------------------------------------------+ -| N | Y | N | Y | (file change) update afhi, hash of PB, keep afsi -+---+----+-----+------+---------------------------------------------------+ -| N | N | Y | Y | (new file) create new entry (force has no effect) -+---+----+-----+------+---------------------------------------------------+ -| N | N | N | Y | (new file) create new entry -+---+----+-----+------+---------------------------------------------------+ - -afhi <=> force or no HS +AFHI: Whether afhi and chunk table are computed and sent. +ACTION: Table modifications to be done by the callback. + ++----+----+---+------+---------------------------------------------------+ +| HS | PB | F | AFHI | ACTION ++----+----+---+------+---------------------------------------------------+ +| Y | Y | Y | Y | if HS != PB: remove PB. HS: force afhi update, +| | update path, keep afsi ++----+----+---+------+---------------------------------------------------+ +| Y | Y | N | N | if HS == PB: do not send callback request at all. +| | otherwise: remove PB, HS: update path, keep afhi, +| | afsi. ++----+----+---+------+---------------------------------------------------+ +| Y | N | Y | Y | (rename) force afhi update of HS, update path of +| | HS, keep afsi ++----+----+---+------+---------------------------------------------------+ +| Y | N | N | N | (file rename) update path of HS, keep afsi, afhi ++----+----+---+------+---------------------------------------------------+ +| N | Y | Y | Y | (file change) update afhi, hash, of PB, keep afsi +| | (force has no effect) ++----+----+---+------+---------------------------------------------------+ +| N | Y | N | Y | (file change) update afhi, hash of PB, keep afsi ++----+----+---+------+---------------------------------------------------+ +| N | N | Y | Y | (new file) create new entry (force has no effect) ++----+----+---+------+---------------------------------------------------+ +| N | N | N | Y | (new file) create new entry ++----+----+---+------+---------------------------------------------------+ + +Notes: + + afhi <=> force or no HS + F => AFHI */ @@ -1484,16 +1562,16 @@ static int com_add_callback(const struct osl_object *query, char asc[2 * HASH_SIZE + 1]; int ret; char afsi_buf[AFSI_SIZE]; - uint32_t flags = read_u32(buf + AFTROW_FLAGS_OFFSET); + uint32_t flags = read_u32(buf + CAB_FLAGS_OFFSET); struct afs_info default_afsi = {.last_played = 0}; struct para_buffer msg = {.buf = NULL}; - hash = (HASH_TYPE *)buf + AFTROW_HASH_OFFSET; + hash = (HASH_TYPE *)buf + CAB_HASH_OFFSET; hash_to_asc(hash, asc);; - objs[AFTCOL_HASH].data = buf + AFTROW_HASH_OFFSET; + objs[AFTCOL_HASH].data = buf + CAB_HASH_OFFSET; objs[AFTCOL_HASH].size = HASH_SIZE; - path = buf + AFTROW_PATH_OFFSET; + path = buf + CAB_PATH_OFFSET; objs[AFTCOL_PATH].data = path; objs[AFTCOL_PATH].size = strlen(path) + 1; @@ -1535,8 +1613,8 @@ static int com_add_callback(const struct osl_object *query, goto out; } /* no hs or force mode, child must have sent afhi */ - uint16_t afhi_offset = read_u16(buf + AFTROW_AFHI_OFFSET_POS); - uint16_t chunks_offset = read_u16(buf + AFTROW_CHUNKS_OFFSET_POS); + uint16_t afhi_offset = read_u16(buf + CAB_AFHI_OFFSET_POS); + uint16_t chunks_offset = read_u16(buf + CAB_CHUNKS_OFFSET_POS); objs[AFTCOL_AFHI].data = buf + afhi_offset; objs[AFTCOL_AFHI].size = chunks_offset - afhi_offset; @@ -1580,20 +1658,20 @@ static int com_add_callback(const struct osl_object *query, if (flags & ADD_FLAG_VERBOSE) para_printf(&msg, "new file\n"); default_afsi.last_played = time(NULL) - 365 * 24 * 60 * 60; - default_afsi.audio_format_id = read_u8(buf + AFTROW_AUDIO_FORMAT_OFFSET); + default_afsi.audio_format_id = read_u8(buf + CAB_AUDIO_FORMAT_OFFSET); objs[AFTCOL_AFSI].data = &afsi_buf; 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)); + para_printf(&msg, "%s\n", para_strerror(-ret)); if (!msg.buf) return 0; result->data = msg.buf; result->size = msg.size; - afs_event(AUDIO_FILE_ADD, &msg, aft_row); return 1; } @@ -1636,7 +1714,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; @@ -1661,7 +1739,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. */ @@ -1670,27 +1748,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); @@ -1699,34 +1777,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); + save_add_callback_buffer(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, - PARA_STRERROR(-ret)); + 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) @@ -1766,7 +1842,8 @@ int com_add(int fd, int argc, char * const * const argv) char *path; ret = verify_path(argv[i], &path); if (ret < 0) { - ret = send_va_buffer(fd, "%s: %s\n", argv[i], PARA_STRERROR(-ret)); + ret = send_va_buffer(fd, "%s: %s\n", argv[i], + para_strerror(-ret)); if (ret < 0) return ret; continue; @@ -1786,7 +1863,7 @@ int com_add(int fd, int argc, char * const * const argv) else ret = add_one_audio_file(path, &pad); if (ret < 0) { - send_va_buffer(fd, "%s: %s\n", path, PARA_STRERROR(-ret)); + send_va_buffer(fd, "%s: %s\n", path, para_strerror(-ret)); free(path); return ret; } @@ -1828,6 +1905,8 @@ struct touch_action_data { struct com_touch_options *cto; /** Message buffer. */ struct para_buffer pb; + /** How many audio files matched the given pattern. */ + unsigned num_matches; }; static int touch_audio_file(__a_unused struct osl_table *table, @@ -1842,12 +1921,12 @@ static int touch_audio_file(__a_unused struct osl_table *table, ret = get_afsi_object_of_row(row, &obj); if (ret < 0) { - para_printf(&tad->pb, "%s: %s\n", name, PARA_STRERROR(-ret)); + para_printf(&tad->pb, "%s: %s\n", name, para_strerror(-ret)); return 1; } ret = load_afsi(&old_afsi, &obj); if (ret < 0) { - para_printf(&tad->pb, "%s: %s\n", name, PARA_STRERROR(-ret)); + para_printf(&tad->pb, "%s: %s\n", name, para_strerror(-ret)); return 1; } new_afsi = old_afsi; @@ -1870,6 +1949,7 @@ static int touch_audio_file(__a_unused struct osl_table *table, if (tad->cto->last_played >= 0) new_afsi.last_played = tad->cto->last_played; } + tad->num_matches++; save_afsi(&new_afsi, &obj); /* in-place update */ aced.aft_row = row; aced.old_afsi = &old_afsi; @@ -1895,7 +1975,10 @@ static int com_touch_callback(const struct osl_object *query, pmd.fnmatch_flags |= FNM_PATHNAME; ret = for_each_matching_row(&pmd); if (ret < 0) - para_printf(&tad.pb, "%s\n", PARA_STRERROR(-ret)); + para_printf(&tad.pb, "%s\n", para_strerror(-ret)); + else + if (!tad.num_matches) + para_printf(&tad.pb, "no matches\n"); if (tad.pb.buf) { result->data = tad.pb.buf; result->size = tad.pb.size; @@ -1963,11 +2046,14 @@ int com_touch(int fd, int argc, char * const * const argv) return -E_AFT_SYNTAX; ret = send_option_arg_callback_request(&query, argc - i, argv + i, com_touch_callback, &result); - if (ret > 0) { - send_buffer(fd, (char *)result.data); - free(result.data); - } else if (ret < 0) - send_va_buffer(fd, "%s\n", PARA_STRERROR(-ret)); + if (!ret) + return 0; + if (ret < 0) { + send_va_buffer(fd, "%s\n", para_strerror(-ret)); + return ret; + } + ret = send_buffer(fd, (char *)result.data); + free(result.data); return ret; } @@ -2002,7 +2088,7 @@ static int remove_audio_file(__a_unused struct osl_table *table, afs_event(AUDIO_FILE_REMOVE, &crd->pb, row); ret = osl_del_row(audio_file_table, row); if (ret < 0) - para_printf(&crd->pb, "%s: %s\n", name, PARA_STRERROR(-ret)); + para_printf(&crd->pb, "%s: %s\n", name, para_strerror(-ret)); else crd->num_removed++; return 1; @@ -2026,7 +2112,7 @@ static int com_rm_callback(const struct osl_object *query, pmd.fnmatch_flags |= FNM_PATHNAME; ret = for_each_matching_row(&pmd); if (ret < 0) - para_printf(&crd.pb, "%s\n", PARA_STRERROR(-ret)); + para_printf(&crd.pb, "%s\n", para_strerror(-ret)); if (!crd.num_removed && !(crd.flags & RM_FLAG_FORCE)) para_printf(&crd.pb, "no matches -- nothing removed\n"); else { @@ -2075,11 +2161,14 @@ int com_rm(int fd, int argc, char * const * const argv) return -E_AFT_SYNTAX; ret = send_option_arg_callback_request(&query, argc - i, argv + i, com_rm_callback, &result); - if (ret > 0) { - send_buffer(fd, (char *)result.data); - free(result.data); - } else if (ret < 0) - send_va_buffer(fd, "%s\n", PARA_STRERROR(-ret)); + if (!ret) + return 0; + if (ret < 0) { + send_va_buffer(fd, "%s\n", para_strerror(-ret)); + return ret; + } + ret = send_buffer(fd, (char *)result.data); + free(result.data); return ret; } @@ -2172,7 +2261,7 @@ static int com_cpsi_callback(const struct osl_object *query, ret = for_each_matching_row(&pmd); out: if (ret < 0) - para_printf(&cad.pb, "%s\n", PARA_STRERROR(-ret)); + para_printf(&cad.pb, "%s\n", para_strerror(-ret)); if (cad.flags & CPSI_FLAG_VERBOSE) { if (cad.num_copied) para_printf(&cad.pb, "copied requested afsi from %s " @@ -2236,11 +2325,14 @@ int com_cpsi(int fd, int argc, char * const * const argv) flags = ~(unsigned)CPSI_FLAG_VERBOSE | flags; ret = send_option_arg_callback_request(&options, argc - i, argv + i, com_cpsi_callback, &result); - if (ret > 0) { - send_buffer(fd, (char *)result.data); - free(result.data); - } else - send_va_buffer(fd, "%s\n", PARA_STRERROR(-ret)); + if (!ret) + return 0; + if (ret < 0) { + send_va_buffer(fd, "%s\n", para_strerror(-ret)); + return ret; + } + ret = send_buffer(fd, (char *)result.data); + free(result.data); return ret; } @@ -2255,7 +2347,7 @@ static int check_audio_file(struct osl_row *row, void *data) char *blob_name; if (ret < 0) { - para_printf(pb, "%s\n", PARA_STRERROR(-ret)); + para_printf(pb, "%s\n", para_strerror(-ret)); return 1; } if (stat(path, &statbuf) < 0) @@ -2266,17 +2358,17 @@ static int check_audio_file(struct osl_row *row, void *data) } ret = get_afsi_of_row(row, &afsi); if (ret < 0) { - para_printf(pb, "%s: %s\n", path, PARA_STRERROR(-ret)); + para_printf(pb, "%s: %s\n", path, para_strerror(-ret)); return 1; } ret = lyr_get_name_by_id(afsi.lyrics_id, &blob_name); if (ret < 0) para_printf(pb, "%s lyrics id %u: %s\n", path, afsi.lyrics_id, - PARA_STRERROR(-ret)); + para_strerror(-ret)); ret = img_get_name_by_id(afsi.image_id, &blob_name); if (ret < 0) para_printf(pb, "%s image id %u: %s\n", path, afsi.image_id, - PARA_STRERROR(-ret)); + para_strerror(-ret)); return 1; }