#include "../Audacity.h"

#include "../ProjectSettings.h"

#include <wx/app.h>

#include <wx/button.h>

#include <wx/cmdline.h>

#include <wx/combobox.h>

#include <wx/log.h>

#include <wx/process.h>

#include <wx/sizer.h>

#include <wx/textctrl.h>

#if defined(__WXMSW__)

#include <wx/msw/registry.h> // for wxRegKey

#endif

#include "../FileNames.h"

#include "Export.h"

#include "../Mix.h"

#include "../Prefs.h"

#include "../ShuttleGui.h"

#include "../Tags.h"

#include "../Track.h"

#include "../float_cast.h"

#include "../widgets/FileHistory.h"

#include "../widgets/AudacityMessageBox.h"

#include "../widgets/ProgressDialog.h"

#include "../widgets/Warning.h"

#include "../wxFileNameWrapper.h"

#ifdef USE_LIBID3TAG

#include <id3tag.h>

extern "C" {

struct id3_frame *id3_frame_new(char const *);

}

#endif

class ExportCLOptions final : public wxPanelWrapper

{

ExportCLOptions(wxWindow *parent, int format);

virtual ~ExportCLOptions();

void PopulateOrExchange(ShuttleGui & S);

bool TransferDataToWindow() override;

bool TransferDataFromWindow() override;

void OnBrowse(wxCommandEvent & event);

wxComboBox *mCmd;

FileHistory mHistory;

DECLARE_EVENT_TABLE()

};

#define ID_BROWSE 5000

BEGIN_EVENT_TABLE(ExportCLOptions, wxPanelWrapper)

EVT_BUTTON(ID_BROWSE, ExportCLOptions::OnBrowse)

END_EVENT_TABLE()

ExportCLOptions::ExportCLOptions(wxWindow *parent, int WXUNUSED(format))

}

ExportCLOptions::~ExportCLOptions()

{

TransferDataFromWindow();

}

void ExportCLOptions::PopulateOrExchange(ShuttleGui & S)

{

wxArrayStringEx cmds( mHistory.begin(), mHistory.end() );

auto cmd = cmds[0];

S.StartVerticalLay();

{

S.StartHorizontalLay(wxEXPAND);

{

S.SetSizerProportion(1);

S.StartMultiColumn(3, wxEXPAND);

{

S.SetStretchyCol(1);

mCmd = S.AddCombo(XXO("Command:"),

cmd,

cmds);

S.Id(ID_BROWSE).AddButton(XXO("Browse..."),

wxALIGN_CENTER_VERTICAL);

S.AddFixedText( {} );

S.TieCheckBox(XXO("Show output"),

{wxT("/FileFormats/ExternalProgramShowOutput"),

false});

}

S.EndMultiColumn();

}

S.EndHorizontalLay();

S.AddTitle(XO(

"Data will be piped to standard in. \"%f\" uses the file name in the export window."), 250);

}

S.EndVerticalLay();

}

bool ExportCLOptions::TransferDataToWindow()

{

return true;

}

bool ExportCLOptions::TransferDataFromWindow()

{

ShuttleGui S(this, eIsSavingToPrefs);

PopulateOrExchange(S);

wxString cmd = mCmd->GetValue();

mHistory.Append(cmd);

mHistory.Save(*gPrefs);

gPrefs->Write(wxT("/FileFormats/ExternalProgramExportCommand"), cmd);

gPrefs->Flush();

return true;

}

void ExportCLOptions::OnBrowse(wxCommandEvent& WXUNUSED(event))

{

wxString path;

FileExtension ext;

FileNames::FileType type = FileNames::AllFiles;

#if defined(__WXMSW__)

ext = wxT("exe");

/* i18n-hint files that can be run as programs */

type = { XO("Executables"), { ext } };

#endif

path = FileNames::SelectFile(FileNames::Operation::Open,

XO("Find path to command"),

wxEmptyString,

wxEmptyString,

ext,

{ type },

wxFD_OPEN | wxRESIZE_BORDER,

this);

if (path.empty()) {

return;

}

if (path.Find(wxT(' ')) == wxNOT_FOUND) {

mCmd->SetValue(path);

}

else {

mCmd->SetValue(wxT('"') + path + wxT('"'));

}

mCmd->SetInsertionPointEnd();

return;

}

static void Drain(wxInputStream *s, wxString *o)

}

class ExportCLProcess final : public wxProcess

};

class ExportCL final : public ExportPlugin

};

ExportCL::ExportCL()

}

ProgressResult ExportCL::Export(AudacityProject *project,

std::unique_ptr<ProgressDialog> &pDialog,

unsigned channels,

const wxFileNameWrapper &fName,

bool selectionOnly,

double t0,

double t1,

MixerSpec *mixerSpec,

const Tags *metadata,

int WXUNUSED(subformat))

{

ExtendPath ep;

wxString output;

long rc;

const auto path = fName.GetFullPath();

GetSettings();

// Bug 2178 - users who don't know what they are doing will

// now get a file extension of .wav appended to their ffmpeg filename

// and therefore ffmpeg will be able to choose a file type.

if( mCmd == wxT("ffmpeg -i - \"%f\"") && !fName.HasExt())

mCmd.Replace( "%f", "%f.wav" );

mCmd.Replace(wxT("%f"), path);

// Kick off the command

ExportCLProcess process(&output);

rc = wxExecute(mCmd, wxEXEC_ASYNC, &process);

if (!rc) {

AudacityMessageBox( XO("Cannot export audio to %s").Format( path ) );

process.Detach();

process.CloseOutput();

return ProgressResult::Cancelled;

}

// Turn off logging to prevent broken pipe messages

wxLogNull nolog;

// establish parameters

int rate = lrint( ProjectSettings::Get( *project ).GetRate());

const size_t maxBlockLen = 44100 * 5;

unsigned long totalSamples = lrint((t1 - t0) * rate);

unsigned long sampleBytes = totalSamples * channels * SAMPLE_SIZE(floatSample);

wxOutputStream *os = process.GetOutputStream();

// RIFF header

struct {

char riffID[4]; // "RIFF"

wxUint32 riffLen; // basically the file len - 8

char riffType[4]; // "WAVE"

} riff;

// format chunk */

struct {

char fmtID[4]; // "fmt " */

wxUint32 formatChunkLen; // (format chunk len - first two fields) 16 in our case

wxUint16 formatTag; // 1 for PCM

wxUint16 channels;

wxUint32 sampleRate;

wxUint32 avgBytesPerSec; // sampleRate * blockAlign

wxUint16 blockAlign; // bitsPerSample * channels (assume bps % 8 = 0)

wxUint16 bitsPerSample;

} fmt;

// id3 chunk header

struct {

char id3ID[4]; // "id3 "

wxUint32 id3Len; // length of metadata in bytes

} id3;

// data chunk header

struct {

char dataID[4]; // "data"

wxUint32 dataLen; // length of all samples in bytes

} data;

riff.riffID[0] = 'R';

riff.riffID[1] = 'I';

riff.riffID[2] = 'F';

riff.riffID[3] = 'F';

riff.riffLen = wxUINT32_SWAP_ON_BE(sizeof(riff) +

sizeof(fmt) +

sizeof(data) +

sampleBytes -

8);

riff.riffType[0] = 'W';

riff.riffType[1] = 'A';

riff.riffType[2] = 'V';

riff.riffType[3] = 'E';

fmt.fmtID[0] = 'f';

fmt.fmtID[1] = 'm';

fmt.fmtID[2] = 't';

fmt.fmtID[3] = ' ';

fmt.formatChunkLen = wxUINT32_SWAP_ON_BE(16);

fmt.formatTag = wxUINT16_SWAP_ON_BE(3);

fmt.channels = wxUINT16_SWAP_ON_BE(channels);

fmt.sampleRate = wxUINT32_SWAP_ON_BE(rate);

fmt.bitsPerSample = wxUINT16_SWAP_ON_BE(SAMPLE_SIZE(floatSample) * 8);

fmt.blockAlign = wxUINT16_SWAP_ON_BE(fmt.bitsPerSample * fmt.channels / 8);

fmt.avgBytesPerSec = wxUINT32_SWAP_ON_BE(fmt.sampleRate * fmt.blockAlign);

// Retrieve tags if not given a set

if (metadata == NULL) {

metadata = &Tags::Get(*project);

}

auto metachunk = GetMetaChunk(metadata);

if (metachunk.size()) {

id3.id3ID[0] = 'i';

id3.id3ID[1] = 'd';

id3.id3ID[2] = '3';

id3.id3ID[3] = ' ';

id3.id3Len = wxUINT32_SWAP_ON_BE(metachunk.size());

riff.riffLen += sizeof(id3) + metachunk.size();

}

data.dataID[0] = 'd';

data.dataID[1] = 'a';

data.dataID[2] = 't';

data.dataID[3] = 'a';

data.dataLen = wxUINT32_SWAP_ON_BE(sampleBytes);

// write the headers and metadata

os->Write(&riff, sizeof(riff));

os->Write(&fmt, sizeof(fmt));

if (metachunk.size()) {

os->Write(&id3, sizeof(id3));

os->Write(metachunk.data(), metachunk.size());

}

os->Write(&data, sizeof(data));

// Mix 'em up

const auto &tracks = TrackList::Get( *project );

auto mixer = CreateMixer(

tracks,

selectionOnly,

t0,

t1,

channels,

maxBlockLen,

true,

rate,

floatSample,

mixerSpec);

size_t numBytes = 0;

samplePtr mixed = NULL;

auto updateResult = ProgressResult::Success;

{

auto closeIt = finally ( [&] {

// Should make the process die, before propagating any exception

process.CloseOutput();

} );

// Prepare the progress display

InitProgress( pDialog, XO("Export"),

selectionOnly

? XO("Exporting the selected audio using command-line encoder")

: XO("Exporting the audio using command-line encoder") );

auto &progress = *pDialog;

// Start piping the mixed data to the command

while (updateResult == ProgressResult::Success && process.IsActive() && os->IsOk()) {

// Capture any stdout and stderr from the command

Drain(process.GetInputStream(), &output);

Drain(process.GetErrorStream(), &output);

// Need to mix another block

if (numBytes == 0) {

auto numSamples = mixer->Process(maxBlockLen);

if (numSamples == 0) {

break;

}

mixed = mixer->GetBuffer();

numBytes = numSamples * channels;

// Byte-swapping is necessary on big-endian machines, since

// WAV files are little-endian

#if wxBYTE_ORDER == wxBIG_ENDIAN

float *buffer = (float *) mixed;

for (int i = 0; i < numBytes; i++) {

buffer[i] = wxUINT32_SWAP_ON_BE(buffer[i]);

}

#endif

numBytes *= SAMPLE_SIZE(floatSample);

}

// Don't write too much at once...pipes may not be able to handle it

size_t bytes = wxMin(numBytes, 4096);

numBytes -= bytes;

while (bytes > 0) {

os->Write(mixed, bytes);

if (!os->IsOk()) {

updateResult = ProgressResult::Cancelled;

break;

}

bytes -= os->LastWrite();

mixed += os->LastWrite();

}

// Update the progress display

updateResult = progress.Update(mixer->MixGetCurrentTime() - t0, t1 - t0);

}

// Done with the progress display

}

// Wait for process to terminate

while (process.IsActive()) {

wxMilliSleep(10);

wxTheApp->Yield();

}

// Display output on error or if the user wants to see it

if (process.GetStatus() != 0 || mShow) {

// TODO use ShowInfoDialog() instead.

wxDialogWrapper dlg(nullptr,

wxID_ANY,

XO("Command Output"),

wxDefaultPosition,

wxSize(600, 400),

wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER);

dlg.SetName();

ShuttleGui S(&dlg, eIsCreating);

S

.Style( wxTE_MULTILINE | wxTE_READONLY | wxTE_RICH )

.AddTextWindow(mCmd + wxT("\n\n") + output);

S.StartHorizontalLay(wxALIGN_CENTER, false);

{

S.Id(wxID_OK).AddButton(XXO("&OK"), wxALIGN_CENTER, true);

}

dlg.GetSizer()->AddSpacer(5);

dlg.Layout();

dlg.SetMinSize(dlg.GetSize());

dlg.Center();

dlg.ShowModal();

if (process.GetStatus() != 0)

updateResult = ProgressResult::Failed;

}

return updateResult;

}

std::vector<char> ExportCL::GetMetaChunk(const Tags *tags)

}

void ExportCL::OptionsCreate(ShuttleGui &S, int format)

{

S.AddWindow( safenew ExportCLOptions{ S.GetParent(), format } );

}

bool ExportCL::CheckFileName(wxFileName &filename, int WXUNUSED(format))

}

void ExportCL::GetSettings()

}

static Exporter::RegisteredExportPlugin sRegisteredPlugin{ "CommandLine",

[]{ return std::make_unique< ExportCL >(); }

};