Example #1
0
        internal AtomToMetadataAdapter(Mp4 mp4, AtomInfo[] atoms)
        {
            Contract.Requires(mp4 != null);
            Contract.Requires(atoms != null);

            foreach (AtomInfo atom in atoms)
            {
                byte[] atomData = mp4.ReadAtom(atom);

                switch (atom.FourCC)
                {
                case "trkn":
                    var trackNumberAtom = new TrackNumberAtom(atomData);
                    Add("TrackNumber", trackNumberAtom.TrackNumber.ToString(CultureInfo.InvariantCulture));
                    if (trackNumberAtom.TrackCount > 0)
                    {
                        Add("TrackCount", trackNumberAtom.TrackCount.ToString(CultureInfo.InvariantCulture));
                    }
                    break;

                case "©day":
                    // The ©day atom may contain a full date, or only the year:
                    var      dayAtom = new TextAtom(atomData);
                    DateTime result;
                    if (DateTime.TryParse(dayAtom.Value, CultureInfo.CurrentCulture, DateTimeStyles.NoCurrentDateDefault, out result) && result.Year >= 1000)
                    {
                        base["Day"]   = result.Day.ToString(CultureInfo.InvariantCulture);
                        base["Month"] = result.Month.ToString(CultureInfo.InvariantCulture);
                        base["Year"]  = result.Year.ToString(CultureInfo.InvariantCulture);
                    }
                    else
                    {
                        base["Year"] = dayAtom.Value;
                    }
                    break;

                case "covr":
                    try
                    {
                        CoverArt = new CoverArt(new CovrAtom(atomData).Value);
                    }
                    catch (UnsupportedCoverArtException)
                    { }
                    break;

                default:
                    string mappedKey;
                    if (_map.TryGetValue(atom.FourCC, out mappedKey))
                    {
                        base[mappedKey] = new TextAtom(atomData).Value;
                    }
                    break;
                }
            }
        }
        internal MetadataToAtomAdapter(MetadataDictionary metadata, SettingsDictionary settings)
        {
            Contract.Requires(metadata != null);

            var day                 = 0;
            var month               = 0;
            var year                = 0;
            var trackNumberAtom     = new TrackNumberAtom();
            var trackSoundCheckAtom = new SoundCheckAtom();
            var albumSoundCheckAtom = new SoundCheckAtom();

            foreach (var item in metadata)
            {
                switch (item.Key)
                {
                case "Day":
                    day = int.Parse(item.Value, CultureInfo.InvariantCulture);
                    break;

                case "Month":
                    month = int.Parse(item.Value, CultureInfo.InvariantCulture);
                    break;

                case "Year":
                    year = int.Parse(item.Value, CultureInfo.InvariantCulture);
                    break;

                case "TrackNumber":
                    trackNumberAtom.TrackNumber = byte.Parse(item.Value, CultureInfo.InvariantCulture);
                    break;

                case "TrackCount":
                    trackNumberAtom.TrackCount = byte.Parse(item.Value, CultureInfo.InvariantCulture);
                    break;

                case "TrackGain":
                    trackSoundCheckAtom.Gain = item.Value;
                    break;

                case "TrackPeak":
                    trackSoundCheckAtom.Peak = item.Value;
                    break;

                case "AlbumGain":
                    albumSoundCheckAtom.Gain = item.Value;
                    break;

                case "AlbumPeak":
                    albumSoundCheckAtom.Peak = item.Value;
                    break;

                default:
                    string fourCC;
                    if (_map.TryGetValue(item.Key, out fourCC))
                    {
                        Add(new TextAtom(fourCC, item.Value));
                    }
                    break;
                }
            }

            // The ©day atom should contain either a full date, or just the year:
            if (day > 0 && month > 0 && year > 0)
            {
                Contract.Assume(month <= 12);
                Add(new TextAtom("©day", new DateTime(year, month, day).ToShortDateString()));
            }
            else if (year > 0)
            {
                Add(new TextAtom("©day", year.ToString(CultureInfo.InvariantCulture)));
            }

            if (trackNumberAtom.IsValid)
            {
                Add(trackNumberAtom);
            }

            if (!string.IsNullOrEmpty(settings["AddSoundCheck"]) &&
                string.Compare(settings["AddSoundCheck"], bool.FalseString, StringComparison.OrdinalIgnoreCase) != 0)
            {
                if (string.Compare(settings["AddSoundCheck"], "Album", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    if (string.IsNullOrEmpty(albumSoundCheckAtom.Gain))
                    {
                        throw new InvalidSettingException(Resources.MetadataToAtomAdapterMissingAlbumGain);
                    }
                    if (string.IsNullOrEmpty(albumSoundCheckAtom.Peak))
                    {
                        throw new InvalidSettingException(Resources.MetadataToAtomAdapterMissingAlbumPeak);
                    }

                    // Place this atom at the beginning:
                    Insert(0, albumSoundCheckAtom);
                }
                else if (string.Compare(settings["AddSoundCheck"], "Track", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    if (string.IsNullOrEmpty(trackSoundCheckAtom.Gain))
                    {
                        throw new InvalidSettingException(Resources.MetadataToAtomAdapterMissingTrackGain);
                    }
                    if (string.IsNullOrEmpty(trackSoundCheckAtom.Peak))
                    {
                        throw new InvalidSettingException(Resources.MetadataToAtomAdapterMissingTrackPeak);
                    }

                    // Place this atom at the beginning:
                    Insert(0, trackSoundCheckAtom);
                }
                else
                {
                    throw new InvalidSettingException(string.Format(CultureInfo.CurrentCulture,
                                                                    Resources.MetadataToAtomAdapterBadAddSoundCheck, settings["AddSoundCheck"]));
                }
            }

            if (metadata.CoverArt != null)
            {
                Add(new CovrAtom(metadata.CoverArt));
            }
        }