mp4: Merge write_int32() into mp4_meta_update().

It has only this single caller, and it's short. Use uint8_t instead
of int8_t for the buffer as we do elsewhere and rename the buffer
variable while at it.

mp4: Simplify mp4_meta_update().

Move duplicated common code out of the if/else branches and kill a
pointless variable.

mp4: Avoid camel case for members of struct mp4_track.

Only three members of struct mp4 are in camel case while all others
follow the underscore convention, which is the standard coding style
of the paraslash code base. Let's be consistent here.

Add comments which indicate the origin of the values stored while
at it.

mp4: Kill fix_byte_order_32().

All quantities stored in mp4 files are in big endian format, There's
no reason to "fix" anything, just write out the 32 bit numbers using
write_u32_be().

mp4: Avoid duplicating the list of atoms.

A little cpp magic can do wonders in this regard. The new
atom_name_to_type() should also be more efficient because we replaced
four 8-bit comparisons by one 32-bit comparison.

mp4: Merge parse_leaf_atom() into parse_sub_atoms().

This gets rid of the distinction between atoms with and without
subatoms, which was confusing because some atoms "without" subatoms
in fact do contain subatoms, we just did not want to parse them
recursively in parse_sub_atoms().

With this weirdness gone, we may move on to simplify the atoms enum and
atom_name_to_type() further, but this is left to a subsequent patch.

mp4: Simplify parse_sub_atoms().

This converts the while loop into a for loop and replaces the
counted_size variable by "dest" to clarify the loop structure. We
also move the two 8-bit variables into the loop as they are only used
there and skip their pointless initializations.

mp4: Use automatic numbering for atom enum.

The exact numbers numbers of the ATOM enum are irrelevant. The only
thing which matters is the distinction between atoms we are only
interested in because they contain subatoms we care about and atoms
for which there is a corresponding read_xxx() parser.

mp4: Remove unused atoms.

The enum and atom_name_to_type() still knows about a lot of atoms we
don't care about. These only clutter up the code and slow things down,
so drop them.

mp4: Kill membuffer API.

Thanks to the previous cleanups, create_ilst() is the last remaining
membuffer user. Since the size of the ilst atom can be computed as the
sum of the tag lengths plus a constant times the number of tag items,
we can allocate a suitably sized buffer up-front instead of relying
on the membuffer framework to allocate and resize buffers as needed.

mp4: Assume udta, meta and ilst are always present.

Under normal circumstances these atoms exist or can at least be
created by other means (e.g., by running mp4tags -a foo bar.m4a).

This patch makes mp4_open_meta() fail early if at least one of the
three atoms is missing. This allows to remove the (never tested hence
probably buggy) code which creates these atoms.

mp4: Merge membuffer_write_std_tag() into create_ilst().

The former is short and is only called by the latter.

mp4: Eliminate duplication between the two open functions.

The only difference between mp4_open_read() and mp4_open_meta()
is that they pass different values for the meta_only flag to
parse_root_atoms(). We can avoid some duplication by moving the
common code to parse_root_atoms(). Rename that function to open_file()
because it now does more than just parsing atoms.

The patch also changes the prototype of both public open functions
to return an integer error code in addition to the pointer to an mp4
structure. This allows us to gradually improve the error diagnostics.

mp4: Remove find_atom() and find_atom_v2().

During mp4_open_meta() we encounter the ILST, META and UDTA atoms
but don't record the size and the location of these atoms. Doing
so allows us to use this information later in mp4_meta_update()
instead of calling find_atom() or find_atom_v2() to search the file
again. This removes some ugly code and speeds up the operation.

mp4: Get rid of find_standard_meta().

We don't need a dedicated function and data structure for that. Just
open-code the logic in create_ilst() and clean up this function a bit
while at it. Specifically:

* Call the loop variable "n" rather than "metaptr" since it is not
a pointer but an unsigned integer.

* Abort if we encounter a tag item name which is not one of the five
standard names. This can never occur because the origin of these
strings is the code in aac_afh.c which only passes standard names.

* Drop the integer return value, since the function can never
fail. Make it return the buffer pointer instead and get rid of the
corresponding parameter.

mp4: Improve parse_tag().

* Merge tag_add_field() and read_string() into parse_tag() since they
are simple enough and have only one caller.

* Avoid memory leaks in the error case.

* Let the function return an error code (rather than -1) in all cases,
and check the return value in the callers.

* Add a sanity check for the subsize.

* Avoid creating two copies of the tag value.

* Rename the variable for the tag value.

mp4: Simplify read_mp4a().

The single caller resets the file offset after the call, so we may
stop reading the atom after we've parsed the last field of interest,
which happens to be the sample rate.

mp4: Remove two local unused header_size variables.

The header size is an optional pointer argument of atom_read_header(),
i.e., callers may pass NULL if they aren't interested in the atom
header size.

mp4: Rename atom_read() to parse_leaf_atom().

For consistency and symmetry with parse_subatoms().

mp4: Reduce atom parsing to the bare minimum.

This replaces need_parse_when_meta_only() by need_atom() which is
called from parse_sub_atoms() for both regular opens and meta-only
opens to decide if the detected atom needs to be parsed.

After this patch we skip more atoms than we used to do, speeding up
the operation for both kinds of opens.

mp4: Convert "meta_only" to a boolean.

Several functions receive the "meta_only" parameter to distinguish
between regular and metadata-only opens. The parameter can only be
zero or one, so use a boolean because true/false is more descriptive
than 1/0.

mp4: Simplify parse_atoms().

We are only interested in subatoms of the moov atom, so skip everything
else. Rename the function to parse_root_atoms() and remove the comment
which does not convey any information anymore.

mp4: Remove two unused arrays from struct mp4_track.

These arrays are allocated and initialized but their values are
never read.

mp4: Hide tracks array.

All functions of mp4.c operate on the first audio track. This
patch makes this fact implicit which allows us to remove the public
mp4_get_total_tracks() and mp4_is_audio_track(). Moreover, the track
parameter can be removed from all public functions.

If no audio track was found in the mp4 file, we now return an error
from two public open functions of mp4.c. Otherwise, we maintain a
pointer to the first audio track within the mp4 structure and use
that to identify the track rather than letting the API users pass
the track number.

mp4: Simplify chunk_of_sample().

This function was unnecessarily complex. The equivalent replacement
code is much shorter and easier to read. Besides reducing the number
of local variables, we drop the chunk_sample parameter and return
this number via the return value of the function.

mp4: Merge chunk_to_offset() into mp4_set_sample_position().

Another equivalent transformation which shortens the code and improves
readability.

mp4: Merge sample_range_size() into mp4_set_sample_position().

This equivalent transformation shortens the code and improves
readability.

mp4: Provide return value for mp4_set_sample_position().

This function fails if the given parameters are invalid. Detect this
and return EINVAL in this case. Add corresponding error checking to
the aac audio format handler.

mp4: Simplify sample_range_size().

Reduce indentation by making the else branch unconditional and simply
call the track pointer "t" rather than "p_track".

mp4: Merge sample_to_offset() into mp4_set_sample_position().

The former is only called by the latter, and both are
short. De-obfuscate the code a little by avoiding pointless local
variables.

mp4: Rename mp4_total_tracks() to mp4_get_total_tracks().

Just to be consistent with other public functions whose name contain
a predicate. Move the function down to related functions.

mp4: Remove ->error of struct mp4.

It's easier to have track_add(), the only function which sets ->error,
return an integer error code instead. Since track_add() is simple
and is only called by parse_sub_atoms(), open-code the logic there.

Also, don't reset ->total_tracks on errors because this leads to a
memory leak, don't increase the track counter on errors and remove
the comment which only states what is obvious.

mp4: Add error checking to parse_atoms() and friends.

After this patch read errors are propagated all the way down from the
read_data() primitive to the public entry functions mp4_open_read()
and mp4_open_meta().

mp4: Add error checking for atom_read().

While the individual atom parsers all perform error checking and
return an error code, their caller, atom_read(), ignores errors.

Address this shortcoming, simplify the function by using a switch
instead of an if-else chain and move the descriptions of the atoms
to the enum where they belong.

mp4: Improve handling of read errors.

Currently read_data() of mp4.c is an atrocious mess. The ->read()
callback is defined to return uint32_t, but the return value is
stored in a signed 32 bit integer. Moreover, read_data() contains a
dead store, it handles neither short nor interrupted reads correctly,
and it moves the file position backwards on errors.

While this is easy to fix, a more intricate problem is that most
callers of read_data(), including all read_intX() helpers, ignore the
return value of read_data() and return uninitialized stack contents in
the error case. This is kind of dealt with by the ->read_error member
of struct mp4, but this not more than a kludge, which, according to
the comments, was applied after several CVEs had been filed against
the library.

Let's DTRT here, even though it adds a fair amount of new code:
Check the return value of each read operation and fail early on errors.

We have to distinguish three cases: error, EOF, and success, encoded
as return values -1, 0 and 1, respectively. This commit converts most
functions which read from an mp4 file to this convention. More work
is required as return values are not checked everywhere yet. This was
left for subsequent commits to keep the already large patch within
reasonable size.

Since we don't rely on ->read_error of struct mp4 any more, it can
be removed.

mp4: Remove dead store from find_atom_v2().

The "size" variable is not used in the code which follows the loop
we are breaking out here.

mp4: Move read_intX functions.

This way, they are located next to each other, and are ordered by the
size of the integer value they read.

Pure code movement, no real changes.

mp4: Rename read_char() to read_int8().

That's more to the point, and is consistent with the other functions
which read integer values.

mp4: Make channel count a 16 bit quantity.

It gets initialized by reading an 16 bit integer.

mp4: Make most members of struct mp4_track unsigned.

All of these get initialized by reading an unsigned 32 bit value from
the file, so they should also be unsigned.

mp4: Merge membuffer_free() into membuffer_transfer_from_file().

The latter is the only caller of the former.

mp4: Clean up membuffer_transfer_from_file().

The buffer pointer can never be NULL, so drop this check. Next, instead
of defining a void * pointer and cast it to char *, use char * directly.
Finally, the cast to unsigned has no effect, so drop it.

mp4: Drop return value from membuffer_write() and friends.

This function always returns the value it received via the last
argument. Pointless.

mp4: Remove the membuffer error bit.

Due to the previous cleanups, it is never set, so remove all code
which checks whether the bit is set.

mp4: Free the membuffer in membuffer_detach().

Each call to this function is followed by a call to membuffer_free(),
which frees the membuffer but not the data buffer because that was
set to NULL.

It is simpler to free the membuffer directly in membuffer_detach().

mp4: Simplify membuffer_create().

Since para_malloc() never returns NULL, the error state can only be
zero. Use para_calloc(), skip the zero initializations and kill a
pointless local variable.

mp4: Check return value of membuffer_transfer_from_file().

This function calls the ->read() method of the callback, which may
fail. Currently all three callers ignore the return value and rely
on the fact that the membuffer is set to error state, which will be
detected later.

It's easier and clearer to check for errors in the callers and fail
early on read errors. Since the membuffer is useless in the error
case, free it right away in membuffer_transfer_from_file(). Change
the function to return bool instead of unsigned while at it and remove
a pointless cast in one of its callers.

mp4: Drop integer return type from modify_moov().

This function returns either zero or one to indicate success. On
success, a pointer to a buffer and the buffer size are returned. It
is simpler and less redundant to indicate failure by returning a NULL
buffer pointer. Rather than using a void ** argument for the buffer,
let the function return void *.

mp4: Reduce indentation in modify_moov().

If the condition of the if clause is true, we return early, so
the else clause can be made unconditional.

No real change.

mp4: Merge mp4_close() and tag_delete().

The latter is only called by the former, and both are short enough.
Don't bother to zero out meta->tags and meta->count because we free
the containing mp4 structure as well.

mp4: Rename parse_metadata() to read_ilst().

To make the naming consistent with the other atom parsers. Kill
a pointless cast and unnecessary braces in the caller while at it.

mp4: Clean up membuffer_write_std_tag().

Remove the check for the compilation flag since we never pass "cpil"
to this function. Remove the flags variable whose value is now always
one. Introduce a variable for the string length instead of calling
strlen() three times, and unify the way comments are formatted.

mp4: Clean up find_standard_meta().

Use ARRAY_SIZE() instead of open-coding it, move the stdmetas array
into the function since it is only used there, and make it const.
Also replace 0 by NULL, since the function returns a pointer, and
remove the pointless comment.

Finally, move the function and the declaration of the stdmeta_entry
structure closer to its single user.

mp4: Simplify create_ilst().

This function contains a lot of overhead which is just dead code
for paraslash since we only care about five standard tags, In
particular, we never write custom tags. Removing the single caller
of membuffer_write_custom_tag() left a whole bunch of other functions
and data structures unused, so these can be removed as well.

mp4: Call metadata structures "meta".

Currently they are called "tags" or "data", both of which are confusing
because struct mp4_metadata has a member called "tags", and "data"
is also used for generic buffers in the various I/O helpers.

aac_afh: Simplify aac_afh_rewrite_tags().

This function was disgusting because it listed the five standard
tags in three different ways. The new replace_or_add_tag() avoids
this issue.

mp4: Drop metadata parameter from mp4_meta_update().

The function can as well access the modified metadata structure via
the mp4 pointer. Drop the parameter also from modify_moov() for the
same reason.

mp4: Introduce mp4_get_meta().

Simplify the API by returning a pointer to the metadata structure stored
inside struct mp4. This is easier than having two accessor functions.

mp4: Simplify and speed up metadata editing.

Currently the aac audio format handler first calls mp4_open_meta()
to get the metadata tags, then alters the in-memory structure of the
tags according to the command line options and passes this modified
structure to mp4_meta_update() to rewrite the tags. This latter call
parses the tags again, which is unnecessary overhead.

This patch changes the signature of mp4_meta_update() to accept an
mp4 structure instead of a callback structure and uses that instead
of re-opening the file.

mp4: Fix memory leak in mp4_meta_update().

This function calls modify_moov() which allocates and returns a
possibly large buffer, but this buffer is never freed.

Found by valgrind.

mp4: Simplify and doxify meta tag accessors.

The integer return value is redundant, so get rid of the value
parameter and simplify meta_find_by_name() accordingly. Document that
tag values are allocated on the heap and should be freed by the caller.

mp4: Simplify parse_tag().

We don't care about arbitrarily named tags, and those tags we're
interested in are generally present in form of the standard tags
(ATOM_TITLE, ATOM_ARTIST etc.).

Since we now always call get_metadata_name() to get the string
representation of the tag, we don't need to make a copy any more,
just pass the const pointer directly to tag_add_field().

With this change in place it is obvious that we never pass a NULL or
empty tag name to tag_add_field(), and we don't pass a NULL pointer
for the value argument either, so remove the safety check.

mp4: Simplify parse_tag().

paraslash fundamentally cares only about five metatags. So remove
all code from parse_tag() which handles the tags we don't care about.

mp4: Rename and simplify set_metadata_name()

This function is an atrocious mess. For one, the naming is confusing
because the function does not set the atom name, it *returns* it.
More importantly, the function defines a static array for no good
reason and then hard-codes the array indices in a large switch
statement.

It's much easier to simply return a pointer to a string literal and
perform the strdup operation in the single caller.

mp4: Mark callback function pointers as const.

The code in mp4.c never modifies any of the members of the callback
structure.

mp4: Use uniform names for callback and mp4 structures.

Currently it's a confusing mess, with callbacks called f, ff, or
stream, where the former two are also used for pointers to struct
mp4. Let's call a spade a spade and use cb everywhere for the callbacks
while f is reserved to denote an mp4 pointer.

mp4: Hide ->read_error.

This does not belong into the callback structure whose fields are
supposed to get initialized by the audio format handler. Move it to
the internal struct mp4 instead, next to the existing error counter.

mp4: Open-code pointless truncate_stream().

This trivial one-liner has only a single caller.

mp4: Don't store the sample size in the mp4 structure.

Currently it is set but never read. We need to keep the read_int16()
call, however, to advance the file offset.

mp4: Don't store the stsd entry count.

A local variable in read_stsd() will do as well.

mp4: Remove two unused fields of struct mp4.

These are neither set nor read.

mp4: Don't parse the ctts atom any more.

The ctts sample offsets are useless for paraslash, so get rid of
the parser.

mp4: Don't parse the movie header any more.

The duration and time scale are taken from the audio track while the
values stored in the movie header (if present) are ignored anyway.

mp4: Simplify atom_compare().

No need for a condition here. Change the return type to bool, and
remove the pointless and misspelt comment.

mp4: Don't store track type anymore.

The only thing we care about is whether or not a track is an audio
track. Hence a simple boolean suffices and the "tracks" enum can
be removed.

mp4: Don't parse the esds atom any more.

With the decoder specific config no longer in use, we can simplify
mp4.c further by getting rid of some cryptic and underdocumented code
which no longer does anything useful for us.

mp4: Introduce mp4_is_audio_track().

Currently the aac audio format handler iterates over the tracks
in an mp4 file. For each track it tries to get the audio-specific
configuration by calling mp4_get_decoder_config() and calls into faad
to check whether it is a valid configuration for the aac decoder.

We can simplify all this because the mp4 code already knows the type
of each track, albeit it does not expose this information yet. So
provide the new mp4_is_audio_track() helper and let the aac audio
format handler pick the first track for which this helper returns true.

As an additional benefit, we can remove the now unused
mp4_get_decoder_config().

mp4: Replace mp4ff prefix by mp4.

The additional "ff" does not convey any useful information.

This patch was produced by running

sed -i 's/mp4ff/mp4/g' mp4.c mp4.h aac_afh.c

followed by

sed -i 's/MP4FF/MP4/g' aac_afh.c error.h

and the manual removal of the "ff" suffix in the error strings.

mp4: Rename mp4ff_open_read_metaonly() -> mp4ff_open_meta().

The old name is misleading because the returned file handle is by no
means opened read-only. In fact we call mp4ff_meta_update() on it,
which alters the file to store the modified metadata.

mp4: Introduce mp4ff_get_duration().

This allows us to get rid of an ugly hack in aac_afh.c where we peeked
at the audio-specific config structure to get the scaling factor which
was needed to compute the duration.

mp4: Prefer para_realloc() over plain realloc().

This allows us to skip the NULL check, which simplifies the code a bit.

mp4: Remove const qualifier from non-pointer function arguments.

In contrast to the pointer case, it's generally not very interesting
to know whether a function will modify the automatic variable which
corresponds to a non-pointer argument.

mp4: Whitespace and indentation cleanups for create_ilst().

The only non-trivial cleanup is the reversed logic to reduce the
indentation of the code in the body of the for loop.

mp4: Remove pointless casts in create_ilst().

They have no effect because membuffer_write_int16_tag() takes a
unit16_t value anyway.

mp4: Reduce indentation of create_ilst().

This function contained an indented block for no good reason. No real
change except that a few variables are exposed to the code below the
former block, but this is not a problem.

mp4: Kill pointless stricmp macro.

Just call strcasecmp() directly.

mp4: Make struct mp4ff opaque, hide struct mp4ff_track.

For the former, code outside of mp4.c only needs a pointer while the
latter does not need to be exposed at all.

Fix the indentation of the two declarations while at it.

mp4: Avoid typedefs for data structures.

They only obfuscate the type.

mp4: Fix trivial coding style issues in read_mvhd().

Some comments were located before the corresponding read statement,
some after, and some comments were indented weirdly.

No real change.

mp4: Prefer enums over defines.

Just because the long list of macros clutters the taglist window
in vim.

mp4: Use read/write functions from portable_io.h.

This removes quite a bit of ugly code. In particular, atom_get_size()
is completely unnecessary and can be removed. Since there is no
function in portable_io.h to read a 24 bit integer, we have to add
read_u24_be().

mp4: Strip mp4ff_ prefix from static functions.

This way it is clear from the name which functions are internal.

mp4: Introduce track helper variables.

This reduces the line length and thus improves the readability of the
code.

mp4: Introduce min_body_size() helper.

This increases readability a lot and brings the line length of
mp4ff_parse_tag() down to a reasonable number of characters.

mp4: Remove useless casts in mp4ff_parse_tag().

These casts have no effect because "len" and the second argument of
mp4ff_read_string() are of type uint32_t.

mp4: Rename overlong variable in mp4ff_parse_tag().

The new "parent" name is just as descriptive and saves a few
characters.

mp4: Remove always true condition in mp4ff_parse_tag().

The parentheses are redundant, and "done" can never be true here.

mp4: Trivial cleanups of mp4ff_parse_tag().

The sprintf statement fits in a single line and the curly braces
are redundant.

mp4: Further reduce the indentation of mp4ff_parse_tag().

Handle the easy cases first. Again, this patch looks unreviewable,
but it in essence it is only one large block that is shifted to the
left with no other changes.

mp4: Use a for-loop in mp4ff_parse_tag().

This is equivalent but will allow us to further reduce the indentation
because we now can easily continue the loop.