podcast-dl 11.5.0 → 11.6.0

package/README.md

@@ -49,11 +49,12 @@ Type values surrounded in square brackets (`[]`) can be used as boolean options
 | --episode-source-order            | String              | false    | Attempted order to extract episode audio URL from RSS feed. Default is `"enclosure,link"`.                                                                                                                                    |
 | --episode-transcript-types        | String              | false    | List of allowed transcript types in preferred order. Default is "application/json,application/x-subrip,application/srr,application/srt,text/vtt,text/html,text/plain".                                                        |
 | --season                          | Number              | false    | Only download episodes from specified season. Note: this will only work if the RSS feed includes the `itunes:season` tag on episodes.                                                                                         |
-| --add-mp3-metadata                |                     | false    | Attempts to add a base level of episode metadata to each episode. Recommended only in cases where the original metadata is of poor quality. (**ffmpeg required**)                                                             |
-| --adjust-bitrate                  | String (e.g. "48k") | false    | Attempts to adjust bitrate of episodes. (**ffmpeg required**)                                                                                                                                                                 |
-| --mono                            |                     | false    | Attempts to force episodes into mono. (**ffmpeg required**)                                                                                                                                                                   |
+| --embed-metadata                  |                     | false    | Add metadata to episode files. (**ffmpeg required**)                                                                                                                                                                          |
+| --audio-format                    | String              | false    | Convert audio to format: mp3, m4a, aac, opus, ogg, flac, wav. (**ffmpeg required**)                                                                                                                                           |
+| --adjust-bitrate                  | String (e.g. "48k") | false    | Adjust bitrate of episodes. (**ffmpeg required**)                                                                                                                                                                             |
+| --mono                            |                     | false    | Force episodes into mono. (**ffmpeg required**)                                                                                                                                                                               |
 | --override                        |                     | false    | Override local files on collision.                                                                                                                                                                                            |
-| --always-postprocess              |                     | false    | Always run additional tasks on the file regardless if the file already exists. This includes `--add-mp3-metadata`, `--adjust-bitrate`, `--mono`, and `--exec`.                                                                |
+| --always-postprocess              |                     | false    | Always run additional tasks on the file regardless if the file already exists. This includes `--embed-metadata`, `--audio-format`, `--adjust-bitrate`, `--mono`, and `--exec`.                                                |
 | --reverse                         |                     | false    | Reverse download direction and start at last RSS item.                                                                                                                                                                        |
 | --info                            |                     | false    | Print retrieved podcast info instead of downloading.                                                                                                                                                                          |
 | --list                            | [String]            | false    | Print episode list instead of downloading. Defaults to `"table"` when used as a boolean option. `"json"` is also supported.                                                                                                   |

package/bin/async.js

@@ -182,12 +182,13 @@ export const download = async (options) => {
 };
 
 export const downloadItemsAsync = async ({
-  addMp3MetadataFlag,
   archive,
   archivePrefix,
   attempts,
+  audioFormat,
   basePath,
   bitrate,
+  embedMetadataFlag,
   episodeTemplate,
   episodeCustomTemplateOptions,
   episodeDigits,
@@ -313,20 +314,21 @@ export const downloadItemsAsync = async ({
           const hasEpisodeImage =
             item._episodeImage && fs.existsSync(item._episodeImage.outputPath);
 
-          if (addMp3MetadataFlag || bitrate || mono) {
+          if (embedMetadataFlag || bitrate || mono || audioFormat) {
             logMessage("Running ffmpeg...");
             await runFfmpeg({
-              feed,
-              item,
+              audioFormat,
               bitrate,
-              mono,
-              itemIndex: item._originalIndex,
-              outputPath: finalEpisodePath,
+              embedMetadata: embedMetadataFlag,
               episodeImageOutputPath: hasEpisodeImage
                 ? item._episodeImage.outputPath
                 : undefined,
-              addMp3Metadata: addMp3MetadataFlag,
               ext: audioFileExt,
+              feed,
+              item,
+              itemIndex: item._originalIndex,
+              mono,
+              outputPath: finalEpisodePath,
             });
           }
 

package/bin/bin.js

@@ -32,6 +32,7 @@ const {
   after,
   alwaysPostprocess,
   attempts,
+  audioFormat,
   before,
   episodeDigits,
   episodeNumOffset,
@@ -60,12 +61,15 @@ const {
   threads,
   url,
   userAgent,
-  addMp3Metadata: addMp3MetadataFlag,
+  embedMetadata,
+  addMp3Metadata,
   adjustBitrate: bitrate,
   season,
   trustExt,
 } = opts;
 
+const embedMetadataFlag = embedMetadata || addMp3Metadata;
+
 let { archive } = opts;
 
 const main = async () => {
@@ -209,7 +213,7 @@ const main = async () => {
   const targetItems = getItemsToDownload({
     archive,
     archivePrefix,
-    addMp3MetadataFlag,
+    embedMetadataFlag,
     basePath,
     feed,
     limit,
@@ -239,12 +243,13 @@ const main = async () => {
   );
 
   const { numEpisodesDownloaded, hasErrors } = await downloadItemsAsync({
-    addMp3MetadataFlag,
     archive,
     archivePrefix,
     attempts,
+    audioFormat,
     basePath,
     bitrate,
+    embedMetadataFlag,
     episodeTemplate,
     episodeCustomTemplateOptions,
     episodeDigits,

package/bin/commander.js

@@ -1,6 +1,6 @@
 import { ITEM_LIST_FORMATS } from "./items.js";
 import { logErrorAndExit } from "./logger.js";
-import { AUDIO_ORDER_TYPES, TRANSCRIPT_TYPES } from "./util.js";
+import { AUDIO_FORMATS, AUDIO_ORDER_TYPES, TRANSCRIPT_TYPES } from "./util.js";
 import { createParseNumber, hasFfmpeg } from "./validate.js";
 
 export const setupCommander = (program) => {
@@ -126,20 +126,36 @@ export const setupCommander = (program) => {
       "download episodes only before this date (inclusive)"
     )
     .option(
-      "--add-mp3-metadata",
-      "attempts to add a base level of metadata to episode files using ffmpeg",
+      "--embed-metadata",
+      "add metadata to episode files using ffmpeg",
       hasFfmpeg
     )
     .option(
-      "--adjust-bitrate <string>",
-      "attempts to adjust bitrate of episode files using ffmpeg",
+      "--add-mp3-metadata",
+      "deprecated: use --embed-metadata instead",
       hasFfmpeg
     )
     .option(
-      "--mono",
-      "attempts to force episode files into mono using ffmpeg",
+      "--audio-format <string>",
+      "convert audio to format (mp3, m4a, aac, opus, ogg, flac, wav)",
+      (value) => {
+        if (!AUDIO_FORMATS[value]) {
+          logErrorAndExit(
+            `Invalid audio format: ${value}\nSupported formats: ${Object.keys(
+              AUDIO_FORMATS
+            ).join(", ")}`
+          );
+        }
+
+        return hasFfmpeg(value);
+      }
+    )
+    .option(
+      "--adjust-bitrate <string>",
+      "adjust bitrate of episode files using ffmpeg",
       hasFfmpeg
     )
+    .option("--mono", "force episode files into mono using ffmpeg", hasFfmpeg)
     .option("--override", "override local files on collision")
     .option(
       "--always-postprocess",

package/bin/ffmpeg.js

@@ -1,105 +1,138 @@
-import dayjs from "dayjs";
-import fs from "fs";
-import { execWithPromise } from "./exec.js";
-import { LOG_LEVELS, logMessage } from "./logger.js";
-import { escapeArgForShell, isWin } from "./util.js";
-
-export const runFfmpeg = async ({
-  feed,
-  item,
-  itemIndex,
-  outputPath,
-  episodeImageOutputPath,
-  bitrate,
-  mono,
-  addMp3Metadata,
-  ext,
-}) => {
-  if (!fs.existsSync(outputPath)) {
-    return;
-  }
-
-  const shouldEmbedImage = addMp3Metadata && episodeImageOutputPath;
-  let command = `ffmpeg -loglevel quiet -i ${escapeArgForShell(outputPath)}`;
-
-  if (shouldEmbedImage) {
-    command += ` -i ${escapeArgForShell(episodeImageOutputPath)}`;
-  }
-
-  if (bitrate) {
-    command += ` -b:a ${bitrate}`;
-  }
-
-  if (mono) {
-    command += " -ac 1";
-  }
-
-  if (addMp3Metadata) {
-    const album = feed.title || "";
-    const artist = item.itunes?.author || item.author || "";
-    const title = item.title || "";
-    const subtitle = item.itunes?.subtitle || "";
-    const comment = item.contentSnippet || item.content || "";
-    const disc = item.itunes?.season || "";
-    const track = item.itunes?.episode || `${feed.items.length - itemIndex}`;
-    const episodeType = item.itunes?.episodeType || "";
-    const date = item.pubDate
-      ? dayjs(new Date(item.pubDate)).format("YYYY-MM-DD")
-      : "";
-
-    const metaKeysToValues = {
-      album,
-      artist,
-      album_artist: artist,
-      title,
-      disc,
-      track,
-      "episode-type": episodeType,
-      date,
-    };
-
-    if (!isWin) {
-      // Due to limited escape options, these metadata fields often break in Windows
-      metaKeysToValues.comment = comment;
-      metaKeysToValues.subtitle = subtitle
-    }
-
-    const metadataString = Object.keys(metaKeysToValues)
-      .map((key) => {
-        if (!metaKeysToValues[key]) {
-          return null;
-        }
-
-        const argValue = escapeArgForShell(metaKeysToValues[key]);
-
-        return argValue ? `-metadata ${key}=${argValue}` : null;
-      })
-      .filter((segment) => !!segment)
-      .join(" ");
-
-    command += ` -map_metadata 0 ${metadataString} -codec copy`;
-  }
-
-  if (shouldEmbedImage) {
-    command += ` -map 0 -map 1`;
-  } else {
-    command += ` -map 0`;
-  }
-
-  const tmpMp3Path = `${outputPath}.tmp${ext}`;
-  command += ` ${escapeArgForShell(tmpMp3Path)}`;
-  logMessage("Running command: " + command, LOG_LEVELS.debug);
-
-  try {
-    await execWithPromise(command, { stdio: "ignore" });
-  } catch (error) {
-    if (fs.existsSync(tmpMp3Path)) {
-      fs.unlinkSync(tmpMp3Path);
-    }
-
-    throw error;
-  }
-
-  fs.unlinkSync(outputPath);
-  fs.renameSync(tmpMp3Path, outputPath);
-};
+import dayjs from "dayjs";
+import fs from "fs";
+import { execWithPromise } from "./exec.js";
+import { LOG_LEVELS, logMessage } from "./logger.js";
+import { AUDIO_FORMATS, escapeArgForShell, isWin } from "./util.js";
+
+export const runFfmpeg = async ({
+  audioFormat,
+  bitrate,
+  embedMetadata,
+  episodeImageOutputPath,
+  ext,
+  feed,
+  item,
+  itemIndex,
+  mono,
+  outputPath,
+}) => {
+  if (!fs.existsSync(outputPath)) {
+    return;
+  }
+
+  const shouldEmbedImage = embedMetadata && episodeImageOutputPath;
+  const targetFormat = audioFormat ? AUDIO_FORMATS[audioFormat] : null;
+  const outputExt = targetFormat ? targetFormat.ext : ext;
+
+  let command = `ffmpeg -loglevel quiet -i ${escapeArgForShell(outputPath)}`;
+
+  if (shouldEmbedImage) {
+    command += ` -i ${escapeArgForShell(episodeImageOutputPath)}`;
+  }
+
+  if (bitrate) {
+    command += ` -b:a ${bitrate}`;
+  }
+
+  if (mono) {
+    command += " -ac 1";
+  }
+
+  if (targetFormat) {
+    command += ` -c:a ${targetFormat.codec}`;
+  } else if (embedMetadata && !bitrate && !mono) {
+    command += ` -c:a copy`;
+  }
+
+  if (shouldEmbedImage) {
+    const supportsAttachedPic = targetFormat
+      ? targetFormat.attachedPic
+      : Object.values(AUDIO_FORMATS).find((f) => f.ext === ext)?.attachedPic;
+    command += supportsAttachedPic
+      ? ` -c:v copy -disposition:v:0 attached_pic`
+      : ` -c:v copy`;
+  }
+
+  if (embedMetadata) {
+    const album = feed.title || "";
+    const artist = item.itunes?.author || item.author || "";
+    const title = item.title || "";
+    const subtitle = item.itunes?.subtitle || "";
+    const comment = item.contentSnippet || item.content || "";
+    const disc = item.itunes?.season || "";
+    const track = item.itunes?.episode || `${feed.items.length - itemIndex}`;
+    const episodeType = item.itunes?.episodeType || "";
+    const date = item.pubDate
+      ? dayjs(new Date(item.pubDate)).format("YYYY-MM-DD")
+      : "";
+
+    const metaKeysToValues = {
+      album,
+      artist,
+      album_artist: artist,
+      title,
+      disc,
+      track,
+      "episode-type": episodeType,
+      date,
+    };
+
+    if (!isWin) {
+      // Due to limited escape options, these metadata fields often break in Windows
+      metaKeysToValues.comment = comment;
+      metaKeysToValues.subtitle = subtitle;
+    }
+
+    const metadataString = Object.keys(metaKeysToValues)
+      .map((key) => {
+        if (!metaKeysToValues[key]) {
+          return null;
+        }
+
+        const argValue = escapeArgForShell(metaKeysToValues[key]);
+
+        return argValue ? `-metadata ${key}=${argValue}` : null;
+      })
+      .filter((segment) => !!segment)
+      .join(" ");
+
+    command += ` -map_metadata 0 ${metadataString}`;
+  }
+
+  if (shouldEmbedImage) {
+    command += ` -map 0:a -map 1`;
+  } else if (targetFormat) {
+    command += ` -map 0:a`;
+  } else {
+    command += ` -map 0`;
+  }
+
+  const tmpPath = `${outputPath}.tmp${outputExt}`;
+  command += ` ${escapeArgForShell(tmpPath)}`;
+  logMessage("Running command: " + command, LOG_LEVELS.debug);
+
+  try {
+    await execWithPromise(command, { stdio: "ignore" });
+  } catch (error) {
+    if (fs.existsSync(tmpPath)) {
+      fs.unlinkSync(tmpPath);
+    }
+
+    throw error;
+  }
+
+  fs.unlinkSync(outputPath);
+
+  const finalOutputPath = (() => {
+    if (!targetFormat) {
+      return outputPath;
+    }
+
+    const hasExt = /\.[^.]+$/.test(outputPath);
+    return hasExt
+      ? outputPath.replace(/\.[^.]+$/, outputExt)
+      : outputPath + outputExt;
+  })();
+
+  fs.renameSync(tmpPath, finalOutputPath);
+};

package/bin/items.js

@@ -1,247 +1,247 @@
-import dayjs from "dayjs";
-import path from "path";
-import { getArchive, getArchiveFilename, getArchiveKey } from "./archive.js";
-import { logErrorAndExit } from "./logger.js";
-import { getItemFilename } from "./naming.js";
-import {
-  getEpisodeAudioUrlAndExt,
-  getImageUrl,
-  getLoopControls,
-  getTranscriptUrl,
-  getUrlExt,
-} from "./util.js";
-
-export const ITEM_LIST_FORMATS = ["table", "json"];
-
-export const getItemsToDownload = ({
-  archive,
-  archivePrefix,
-  addMp3MetadataFlag,
-  basePath,
-  feed,
-  limit,
-  offset,
-  reverse,
-  before,
-  after,
-  episodeDigits,
-  episodeNumOffset,
-  episodeRegex,
-  episodeRegexExclude,
-  episodeSourceOrder,
-  episodeTemplate,
-  episodeCustomTemplateOptions,
-  includeEpisodeImages,
-  includeEpisodeTranscripts,
-  episodeTranscriptTypes,
-  season,
-}) => {
-  const { startIndex, shouldGo, next } = getLoopControls({
-    offset,
-    reverse,
-    length: feed.items.length,
-  });
-
-  let i = startIndex;
-  const items = [];
-
-  const savedArchive = archive ? getArchive(archive) : [];
-
-  while (shouldGo(i)) {
-    const { title, pubDate, itunes } = feed.items[i];
-    const actualSeasonNum = itunes?.season ? parseInt(itunes.season) : null;
-    const pubDateDay = dayjs(new Date(pubDate));
-    let isValid = true;
-
-    if (episodeRegex) {
-      const generatedEpisodeRegex = new RegExp(episodeRegex);
-      if (title && !generatedEpisodeRegex.test(title)) {
-        isValid = false;
-      }
-    }
-
-    if (episodeRegexExclude) {
-      const generatedEpisodeRegexExclude = new RegExp(episodeRegexExclude);
-      if (title && generatedEpisodeRegexExclude.test(title)) {
-        isValid = false;
-      }
-    }
-
-    if (before) {
-      const beforeDateDay = dayjs(new Date(before));
-      if (
-        !pubDateDay.isSame(beforeDateDay, "day") &&
-        !pubDateDay.isBefore(beforeDateDay, "day")
-      ) {
-        isValid = false;
-      }
-    }
-
-    if (after) {
-      const afterDateDay = dayjs(new Date(after));
-      if (
-        !pubDateDay.isSame(afterDateDay, "day") &&
-        !pubDateDay.isAfter(afterDateDay, "day")
-      ) {
-        isValid = false;
-      }
-    }
-
-    if (season && season != actualSeasonNum) {
-      isValid = false;
-    }
-
-    const { url: episodeAudioUrl, ext: audioFileExt } =
-      getEpisodeAudioUrlAndExt(feed.items[i], episodeSourceOrder);
-
-    const key = getArchiveKey({
-      prefix: archivePrefix,
-      name: getArchiveFilename({
-        pubDate,
-        name: title,
-        ext: audioFileExt,
-      }),
-    });
-
-    if (key && savedArchive.includes(key)) {
-      isValid = false;
-    }
-
-    if (isValid) {
-      const item = feed.items[i];
-      item._originalIndex = i;
-      item.seasonNum = actualSeasonNum;
-
-      if (includeEpisodeImages || addMp3MetadataFlag) {
-        const episodeImageUrl = getImageUrl(item);
-
-        if (episodeImageUrl) {
-          const episodeImageFileExt = getUrlExt(episodeImageUrl);
-          const episodeImageArchiveKey = getArchiveKey({
-            prefix: archivePrefix,
-            name: getArchiveFilename({
-              pubDate,
-              name: title,
-              ext: episodeImageFileExt,
-            }),
-          });
-
-          const episodeImageName = getItemFilename({
-            item,
-            feed,
-            url: episodeAudioUrl,
-            ext: episodeImageFileExt,
-            template: episodeTemplate,
-            customTemplateOptions: episodeCustomTemplateOptions,
-            width: episodeDigits,
-            offset: episodeNumOffset,
-          });
-
-          const outputImagePath = path.resolve(basePath, episodeImageName);
-          item._episodeImage = {
-            url: episodeImageUrl,
-            outputPath: outputImagePath,
-            key: episodeImageArchiveKey,
-          };
-        }
-      }
-
-      if (includeEpisodeTranscripts) {
-        const episodeTranscriptUrl = getTranscriptUrl(
-          item,
-          episodeTranscriptTypes
-        );
-
-        if (episodeTranscriptUrl) {
-          const episodeTranscriptFileExt = getUrlExt(episodeTranscriptUrl);
-          const episodeTranscriptArchiveKey = getArchiveKey({
-            prefix: archivePrefix,
-            name: getArchiveFilename({
-              pubDate,
-              name: title,
-              ext: episodeTranscriptFileExt,
-            }),
-          });
-
-          const episodeTranscriptName = getItemFilename({
-            item,
-            feed,
-            url: episodeAudioUrl,
-            ext: episodeTranscriptFileExt,
-            template: episodeTemplate,
-            width: episodeDigits,
-            offset: episodeNumOffset,
-          });
-
-          const outputTranscriptPath = path.resolve(
-            basePath,
-            episodeTranscriptName
-          );
-
-          item._episodeTranscript = {
-            url: episodeTranscriptUrl,
-            outputPath: outputTranscriptPath,
-            key: episodeTranscriptArchiveKey,
-          };
-        }
-      }
-
-      items.push(item);
-    }
-
-    i = next(i);
-  }
-
-  return limit ? items.slice(0, limit) : items;
-};
-
-export const logItemsList = ({
-  type,
-  feed,
-  limit,
-  offset,
-  reverse,
-  before,
-  after,
-  episodeRegex,
-  episodeRegexExclude,
-  season,
-}) => {
-  const items = getItemsToDownload({
-    feed,
-    limit,
-    offset,
-    reverse,
-    before,
-    after,
-    episodeRegex,
-    episodeRegexExclude,
-    season,
-  });
-
-  if (!items.length) {
-    logErrorAndExit("No episodes found with provided criteria to list");
-  }
-
-  const isJson = type === "json";
-
-  const output = items.map((item) => {
-    const data = {
-      seasonNum: item.seasonNum,
-      episodeNum: feed.items.length - item._originalIndex,
-      title: item.title,
-      pubDate: item.pubDate,
-    };
-
-    return data;
-  });
-
-  if (isJson) {
-    // eslint-disable-next-line no-console
-    console.log(JSON.stringify(output));
-    return;
-  }
-
-  // eslint-disable-next-line no-console
-  console.table(output);
-};
+import dayjs from "dayjs";
+import path from "path";
+import { getArchive, getArchiveFilename, getArchiveKey } from "./archive.js";
+import { logErrorAndExit } from "./logger.js";
+import { getItemFilename } from "./naming.js";
+import {
+  getEpisodeAudioUrlAndExt,
+  getImageUrl,
+  getLoopControls,
+  getTranscriptUrl,
+  getUrlExt,
+} from "./util.js";
+
+export const ITEM_LIST_FORMATS = ["table", "json"];
+
+export const getItemsToDownload = ({
+  archive,
+  archivePrefix,
+  embedMetadataFlag,
+  basePath,
+  feed,
+  limit,
+  offset,
+  reverse,
+  before,
+  after,
+  episodeDigits,
+  episodeNumOffset,
+  episodeRegex,
+  episodeRegexExclude,
+  episodeSourceOrder,
+  episodeTemplate,
+  episodeCustomTemplateOptions,
+  includeEpisodeImages,
+  includeEpisodeTranscripts,
+  episodeTranscriptTypes,
+  season,
+}) => {
+  const { startIndex, shouldGo, next } = getLoopControls({
+    offset,
+    reverse,
+    length: feed.items.length,
+  });
+
+  let i = startIndex;
+  const items = [];
+
+  const savedArchive = archive ? getArchive(archive) : [];
+
+  while (shouldGo(i)) {
+    const { title, pubDate, itunes } = feed.items[i];
+    const actualSeasonNum = itunes?.season ? parseInt(itunes.season) : null;
+    const pubDateDay = dayjs(new Date(pubDate));
+    let isValid = true;
+
+    if (episodeRegex) {
+      const generatedEpisodeRegex = new RegExp(episodeRegex);
+      if (title && !generatedEpisodeRegex.test(title)) {
+        isValid = false;
+      }
+    }
+
+    if (episodeRegexExclude) {
+      const generatedEpisodeRegexExclude = new RegExp(episodeRegexExclude);
+      if (title && generatedEpisodeRegexExclude.test(title)) {
+        isValid = false;
+      }
+    }
+
+    if (before) {
+      const beforeDateDay = dayjs(new Date(before));
+      if (
+        !pubDateDay.isSame(beforeDateDay, "day") &&
+        !pubDateDay.isBefore(beforeDateDay, "day")
+      ) {
+        isValid = false;
+      }
+    }
+
+    if (after) {
+      const afterDateDay = dayjs(new Date(after));
+      if (
+        !pubDateDay.isSame(afterDateDay, "day") &&
+        !pubDateDay.isAfter(afterDateDay, "day")
+      ) {
+        isValid = false;
+      }
+    }
+
+    if (season && season != actualSeasonNum) {
+      isValid = false;
+    }
+
+    const { url: episodeAudioUrl, ext: audioFileExt } =
+      getEpisodeAudioUrlAndExt(feed.items[i], episodeSourceOrder);
+
+    const key = getArchiveKey({
+      prefix: archivePrefix,
+      name: getArchiveFilename({
+        pubDate,
+        name: title,
+        ext: audioFileExt,
+      }),
+    });
+
+    if (key && savedArchive.includes(key)) {
+      isValid = false;
+    }
+
+    if (isValid) {
+      const item = feed.items[i];
+      item._originalIndex = i;
+      item.seasonNum = actualSeasonNum;
+
+      if (includeEpisodeImages || embedMetadataFlag) {
+        const episodeImageUrl = getImageUrl(item);
+
+        if (episodeImageUrl) {
+          const episodeImageFileExt = getUrlExt(episodeImageUrl);
+          const episodeImageArchiveKey = getArchiveKey({
+            prefix: archivePrefix,
+            name: getArchiveFilename({
+              pubDate,
+              name: title,
+              ext: episodeImageFileExt,
+            }),
+          });
+
+          const episodeImageName = getItemFilename({
+            item,
+            feed,
+            url: episodeAudioUrl,
+            ext: episodeImageFileExt,
+            template: episodeTemplate,
+            customTemplateOptions: episodeCustomTemplateOptions,
+            width: episodeDigits,
+            offset: episodeNumOffset,
+          });
+
+          const outputImagePath = path.resolve(basePath, episodeImageName);
+          item._episodeImage = {
+            url: episodeImageUrl,
+            outputPath: outputImagePath,
+            key: episodeImageArchiveKey,
+          };
+        }
+      }
+
+      if (includeEpisodeTranscripts) {
+        const episodeTranscriptUrl = getTranscriptUrl(
+          item,
+          episodeTranscriptTypes
+        );
+
+        if (episodeTranscriptUrl) {
+          const episodeTranscriptFileExt = getUrlExt(episodeTranscriptUrl);
+          const episodeTranscriptArchiveKey = getArchiveKey({
+            prefix: archivePrefix,
+            name: getArchiveFilename({
+              pubDate,
+              name: title,
+              ext: episodeTranscriptFileExt,
+            }),
+          });
+
+          const episodeTranscriptName = getItemFilename({
+            item,
+            feed,
+            url: episodeAudioUrl,
+            ext: episodeTranscriptFileExt,
+            template: episodeTemplate,
+            width: episodeDigits,
+            offset: episodeNumOffset,
+          });
+
+          const outputTranscriptPath = path.resolve(
+            basePath,
+            episodeTranscriptName
+          );
+
+          item._episodeTranscript = {
+            url: episodeTranscriptUrl,
+            outputPath: outputTranscriptPath,
+            key: episodeTranscriptArchiveKey,
+          };
+        }
+      }
+
+      items.push(item);
+    }
+
+    i = next(i);
+  }
+
+  return limit ? items.slice(0, limit) : items;
+};
+
+export const logItemsList = ({
+  type,
+  feed,
+  limit,
+  offset,
+  reverse,
+  before,
+  after,
+  episodeRegex,
+  episodeRegexExclude,
+  season,
+}) => {
+  const items = getItemsToDownload({
+    feed,
+    limit,
+    offset,
+    reverse,
+    before,
+    after,
+    episodeRegex,
+    episodeRegexExclude,
+    season,
+  });
+
+  if (!items.length) {
+    logErrorAndExit("No episodes found with provided criteria to list");
+  }
+
+  const isJson = type === "json";
+
+  const output = items.map((item) => {
+    const data = {
+      seasonNum: item.seasonNum,
+      episodeNum: feed.items.length - item._originalIndex,
+      title: item.title,
+      pubDate: item.pubDate,
+    };
+
+    return data;
+  });
+
+  if (isJson) {
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify(output));
+    return;
+  }
+
+  // eslint-disable-next-line no-console
+  console.table(output);
+};

package/bin/util.js

@@ -1,8 +1,18 @@
 import fs from "fs";
 import path from "path";
-import rssParser from "rss-parser";
+import rssParser from "../lib/rss-parser/parser.js";
 import { logErrorAndExit, logMessage } from "./logger.js";
 
+export const AUDIO_FORMATS = {
+  m4a: { codec: "aac", ext: ".m4a", attachedPic: true },
+  aac: { codec: "aac", ext: ".aac" },
+  mp3: { codec: "libmp3lame", ext: ".mp3", attachedPic: true },
+  opus: { codec: "libopus", ext: ".opus" },
+  ogg: { codec: "libvorbis", ext: ".ogg" },
+  flac: { codec: "flac", ext: ".flac" },
+  wav: { codec: "pcm_s16le", ext: ".wav" },
+};
+
 export const isWin = process.platform === "win32";
 
 export const defaultRssParserConfig = {
@@ -10,9 +20,6 @@ export const defaultRssParserConfig = {
   headers: {
     Accept: "*/*",
   },
-  customFields: {
-    item: [["podcast:transcript", "podcastTranscripts", { keepArray: true }]],
-  },
 };
 
 /*

package/bin/validate.js

@@ -32,8 +32,10 @@ export const createParseNumber = ({ min, max, name, required = true }) => {
   };
 };
 
-export const hasFfmpeg = () => {
+export const hasFfmpeg = (value) => {
   if (!commandExistsSync("ffmpeg")) {
     logErrorAndExit('option specified requires "ffmpeg" be available');
   }
+
+  return value;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "podcast-dl",
-  "version": "11.5.0",
+  "version": "11.6.0",
   "description": "A CLI for downloading podcasts.",
   "type": "module",
   "bin": "./bin/bin.js",
@@ -57,7 +57,8 @@
     "got": "^11.0.2",
     "p-limit": "^4.0.0",
     "pluralize": "^8.0.0",
-    "rss-parser": "^3.12.0",
+    "entities": "^2.0.3",
+    "xml2js": "^0.5.0",
     "throttle-debounce": "^3.0.1"
   }
 }