#include "stdafx.h"

#include <stdio.h>
#include <stdlib.h>

//-- Estructuras

typedef struct {
    int chunkId,chunkSize,Format,Subchunkid,subchunk1Size;
    short AudioFormat,numChanels;
    int sampleRate,ByteRate;
    short blockAlign,BitsPerSample;
    int subChunk2Id,subChunk2Size;
    unsigned char muestras[59909440];
} Pista; // Estructura para guardar las pistas wav


//-- Prototipos de las funciones
int comparar(char * string1, char * string2); // Funcion que se encarga de comparar dos cadenas de caracteres
int convertir(char * string1); // Funcion que se encarga de convertir un arreglo de caracteres a un numero entero
void cargarArchivo(Pista * pista, char * nom); // Funcion que carga un archivo wav en memoria ram
void cortar(Pista * pistaOrigen, Pista * pistaDestino,int milisegundos); // Funcion que corta una pista hasta la longitud deseada en milisegundos
void introducirEco(Pista * pistaOrigen, Pista * pistaDestino,int milisegundos); // Funcion que introduce eco a un archivo wav
void mezclarPistas(Pista * pista1,Pista * pista2, Pista * pistaDestino); // Funcion que se encarga de mezclar dos pistas
void guardarPista(Pista * pista, char * nomArchivoSalida); // Funcion que guarda el contenido de la estructura imagen en un archivo binario

//-- Funcion main de la aplicacion
// Funcion principal del programa.
// La aplicacion recibe un parametro que indica el tipo de operacion a realizar
// Si la operacion es de eco entonces se esperan tres parametros que son:
//      El primero es el retardo en milisegundos
//      El segundo es la ruta del archivo fuente, en formato wav
//      El tercero es la ruta del archivo destino, en formato wav
// Si la operacion es de mezcla entonces se esperan tres parametros que son:
//      El primero es la ruta del archivo con la primera pista a mezclar
//      El segundo es la ruta del archivo con la segunda pista a mezclar
//      El tercero es la ruta del archivo destino, en formato wav
// Todos los parametros necesarios para una operacion deben ser ingresados para el correcto funcionamiento del programa.
// No hay que completar nada en esta funcion.

int main(int argc, char *argv[]){
    argv[1]="-mezclar";
    argv[2]="C:\\Documents and Settings\\laptop\\Escritorio\\UNIANDES\\INFRAESTRUCTURA TECNOLOGICA\\CICLO 2-PROYECTO\\isis1304-102-Proyecto_2\\isis1304-102-Proyecto 2\\data\\mozart1.wav";
    //argv[2]="5000";
    argv[3]="C:\\Documents and Settings\\laptop\\Escritorio\\UNIANDES\\INFRAESTRUCTURA TECNOLOGICA\\CICLO 2-PROYECTO\\isis1304-102-Proyecto_2\\isis1304-102-Proyecto 2\\data\\muestra1.wav";
    argv[4]="C:\\Documents and Settings\\laptop\\Escritorio\\UNIANDES\\INFRAESTRUCTURA TECNOLOGICA\\CICLO 2-PROYECTO\\isis1304-102-Proyecto_2\\isis1304-102-Proyecto 2\\data\\muestra1y2.wav";
     Pista * pista1, * pista2,*pistaDestino;
    pista1 = (Pista *)malloc(sizeof(Pista)); // Reserva suficiente memoria para la estructura pista uno
    pista2 = (Pista *)malloc(sizeof(Pista)); // Reserva suficiente memoria para la estructura pista dos
    pistaDestino = (Pista *)malloc(sizeof(Pista)); // Reserva suficiente memoria para la estructura pista de destino
    if(comparar(argv[1],"-eco")){
        int eco;
        eco=convertir(argv[2]);
        cargarArchivo(pista1, argv[3]);
        introducirEco(pista1,pistaDestino,eco);
        guardarPista(pistaDestino, argv[4]);
        printf("eco= %d \n",eco);
    }else if(comparar(argv[1],"-cortar")){
        int puntoCorte;
        puntoCorte=convertir(argv[2]);
        cargarArchivo(pista1, argv[3]);
        cortar(pista1,pistaDestino,puntoCorte);
        guardarPista(pistaDestino, argv[4]);
    }else if(comparar(argv[1],"-mezclar")){
        cargarArchivo(pista1, argv[2]);
        cargarArchivo(pista2, argv[3]);
        mezclarPistas(pista1,pista2, pistaDestino);
        guardarPista(pistaDestino, argv[4]);
    }

    system("pause");

    return 0;
}


//-- Funciones
// Esta funcion se encarga de abrir un archivo que contenga un archivo wav
// y la carga en una estructura Pista cuyo apuntador entra como parametro.
// No hay que completar nada en esta funci�n.
void cargarArchivo(Pista * imagen, char * nomArchivoEntrada){
    FILE * archivoEntrada;
    int e=0;
    archivoEntrada = fopen(nomArchivoEntrada, "rb");
    if (archivoEntrada == 0){
        printf("No ha sido posible cargar el archivo: %s\n", nomArchivoEntrada);
        exit(-1);
    }
    fread(&imagen->chunkId, sizeof(int), 1, archivoEntrada);
    fread(&imagen->chunkSize, sizeof(int), 1, archivoEntrada);
    fread(&imagen->Format, sizeof(int), 1, archivoEntrada);
    fread(&imagen->Subchunkid, sizeof(int), 1, archivoEntrada);
    fread(&imagen->subchunk1Size, sizeof(int), 1, archivoEntrada);
    fread(&imagen->AudioFormat, sizeof(short), 1, archivoEntrada);
    fread(&imagen->numChanels, sizeof(short), 1, archivoEntrada);
    fread(&imagen->sampleRate, sizeof(int), 1, archivoEntrada);
    fread(&imagen->ByteRate, sizeof(int), 1, archivoEntrada);
    fread(&imagen->blockAlign, sizeof(short), 1, archivoEntrada);
    fread(&imagen->BitsPerSample, sizeof(short), 1, archivoEntrada);
    fread(&imagen->subChunk2Id, sizeof(int), 1, archivoEntrada);
    fread(&imagen->subChunk2Size, sizeof(int), 1, archivoEntrada);
    fread(&imagen->muestras, sizeof(unsigned char), *(&imagen->subChunk2Size), archivoEntrada);
    fclose(archivoEntrada);
}
/*
 Esta funcion se encarga de introducir eco en la pistaDeOrigen y colocarla la nueva pista en pistaDestino
 Se debe completar en su totalidad esta funcion
*/
void introducirEco(Pista * pistaOrigen, Pista * pistaDestino,int milisegundos){
    long long indice = 0,retraso;
    printf("\n %d \n",sizeof(indice));
    //TODO completar la función en assembler. Recuerde que debe hacer las modificaciones correspondientes en el encabezado del archivo.
    *(&pistaDestino->AudioFormat) = *(&pistaOrigen->AudioFormat);
    *(&pistaDestino->BitsPerSample) = *(&pistaOrigen->BitsPerSample);
    *(&pistaDestino->blockAlign) = *(&pistaOrigen->blockAlign);
    *(&pistaDestino->ByteRate) = *(&pistaOrigen->ByteRate);
    *(&pistaDestino->chunkId) = *(&pistaOrigen->chunkId);
    *(&pistaDestino->chunkSize)= *(&pistaOrigen->chunkSize);
    *(&pistaDestino->Format) = *(&pistaOrigen->Format);


    *(&pistaDestino->numChanels) = *(&pistaOrigen->numChanels);
    *(&pistaDestino->sampleRate) = *(&pistaOrigen->sampleRate);
    *(&pistaDestino->subchunk1Size)= *(&pistaOrigen->subchunk1Size);
    *(&pistaDestino->subChunk2Id) = *(&pistaOrigen->subChunk2Id);
    *(&pistaDestino->subChunk2Size) = *(&pistaOrigen->subChunk2Size);
    *(&pistaDestino->Subchunkid) = *(&pistaOrigen->Subchunkid);
*pistaDestino->muestras = *pistaOrigen->muestras;


}
/*
 Esta funcion se encarga de cortar una pista hasta el tiempo pasado por parametro
 Se debe completar en su totalidad esta funcion
*/
void cortar(Pista * pistaOrigen, Pista * pistaDestino,int milisegundos){
    unsigned long long indice = 0,puntoCorte;
    //TODO completar la función en assembler. Recuerde que debe hacer las modificaciones correspondientes en el encabezado del archivo.
    printf("%d tamaño de punto de corte",sizeof(puntoCorte));

    puntoCorte=milisegundos/1000*44100;

    *(&pistaDestino->sampleRate) =*(&pistaOrigen->sampleRate);

printf("%d sample rate \n",pistaOrigen->sampleRate);
    *(&pistaDestino->AudioFormat)=*(&pistaOrigen->AudioFormat);

    *(&pistaDestino->BitsPerSample) =*(&pistaOrigen->BitsPerSample);

    *(&pistaDestino->blockAlign) =*(&pistaOrigen->blockAlign);

    *(&pistaDestino->ByteRate) =*(&pistaOrigen->ByteRate );

    *(&pistaDestino->chunkId)=*(&pistaOrigen->chunkId );

    *(&pistaDestino->Format) =*(&pistaOrigen->Format);

        *(&pistaDestino->numChanels)=*(&pistaOrigen->numChanels);

        *(&pistaDestino->subchunk1Size) =*(&pistaOrigen->subchunk1Size);

        *(&pistaDestino->subChunk2Id)=*(&pistaOrigen->subChunk2Id);

        *(&pistaDestino->subChunk2Size)=puntoCorte*4;

        *(&pistaDestino->Subchunkid)=*(&pistaOrigen->Subchunkid);

    //  printf("%d subChunk1size \n",pistaOrigen->subchunk1Size);
//printf("%d subChunk2size \n",pistaOrigen->subChunk2Size);
    *(&pistaDestino->chunkSize)=(4+(8+*(&pistaDestino->subChunk2Size))+(8+*(&pistaDestino->subchunk1Size)));


    printf("%d punto de corte \n",puntoCorte);

    for(indice=0;indice<=puntoCorte*4;indice++)
        (pistaDestino->muestras[indice])=(pistaOrigen->muestras[indice]);
}
// Esta funcion se encarga de tomar dos pistas y mezclarlas en la pista de destino
// Se debe completar en su totalidad esta funcion
void mezclarPistas(Pista * pista1,Pista * pista2, Pista * pistaDestino){
    int x = 0;
    Pista * mayor=pista1,* menor=pista2;
    //TODO completar la función en assembler (Puede que pista2 y en consecuencia menor sea la pista de mayor longitud, debe contemplar ese caso). Recuerde que debe hacer las modificaciones correspondientes en el encabezado del archivo.
    if(pista1->muestras < pista2->muestras){
        mayor=pista2;
        menor=pista1;}

    *(&pistaDestino->sampleRate) =(*(&pista1->sampleRate)+*(&pista2->sampleRate))/2;

    *(&pistaDestino->AudioFormat)=(*(&pista1->AudioFormat)+*(&pista2->AudioFormat))/2;

    *(&pistaDestino->BitsPerSample) =(*(&pista1->BitsPerSample)+*(&pista2->BitsPerSample))/2;

    *(&pistaDestino->blockAlign) =(*(&pista1->blockAlign)+*(&pista2->blockAlign))/2;

    *(&pistaDestino->ByteRate) =(*(&pista1->ByteRate)+*(&pista2->ByteRate))/2;

    *(&pistaDestino->chunkId)=*(&mayor->chunkId);

    *(&pistaDestino->Format) =*(&mayor->Format);

        *(&pistaDestino->numChanels)=(*(&pista1->numChanels)+*(&pista2->numChanels))/2;

        *(&pistaDestino->subchunk1Size) =(*(&pista1->subchunk1Size)+*(&pista2->subchunk1Size))/2;

        *(&pistaDestino->subChunk2Id)=  *(&mayor->subChunk2Id);
        *(&pistaDestino->subChunk2Size)=*(&mayor->subChunk2Size);

        *(&pistaDestino->Subchunkid)=(*(&pista1->Subchunkid)+*(&pista2->Subchunkid))/2;

        *(&pistaDestino->chunkSize)=*(&mayor->chunkSize);
    char mask1,mask2,total;

    for(x=0;x<=int(menor->muestras);x++){
            //mask1=(*(&mayor->muestras[x]))*2;
            mask1=(*(&mayor->muestras[x]))+'0'-10;
            mask2= *(&menor->muestras[x])+'0'-10;
            total=(mask1+mask2)/2;
            total-='0';
            total+=10;

            *(&pistaDestino->muestras[x])=(total*2);
            }

}

// Esta funcion se encarga de guardar un archivo wav
// No hay que completar nada en esta funcion.
void guardarPista(Pista * pista, char * nomArchivoSalida){
    FILE * archivoSalida;
    archivoSalida = fopen(nomArchivoSalida, "w+b"); // Archivo donde se va a escribir el wav
    if (archivoSalida == 0){
        printf("No ha sido posible crear el archivo: %s\n", nomArchivoSalida);
        exit(-1);
    }
    fwrite(&pista->chunkId, sizeof(int), 1, archivoSalida);
    fwrite(&pista->chunkSize, sizeof(int), 1, archivoSalida);
    fwrite(&pista->Format, sizeof(int), 1, archivoSalida);
    fwrite(&pista->Subchunkid, sizeof(int), 1, archivoSalida);
    fwrite(&pista->subchunk1Size, sizeof(int), 1, archivoSalida);
    fwrite(&pista->AudioFormat, sizeof(short), 1, archivoSalida);
    fwrite(&pista->numChanels, sizeof(short), 1, archivoSalida);
    fwrite(&pista->sampleRate, sizeof(int), 1, archivoSalida);
    fwrite(&pista->ByteRate, sizeof(int), 1, archivoSalida);
    fwrite(&pista->blockAlign, sizeof(short), 1, archivoSalida);
    fwrite(&pista->BitsPerSample, sizeof(short), 1, archivoSalida);
    fwrite(&pista->subChunk2Id, sizeof(int), 1, archivoSalida);
    fwrite(&pista->subChunk2Size, sizeof(int), 1, archivoSalida);
    fwrite(&pista->muestras, sizeof(unsigned char), *(&pista->subChunk2Size), archivoSalida);
    fclose(archivoSalida);
}

// Funcion que se encarga de comparar dos arreglos de caracteres
// No se debe completar nada de esta funcion
int comparar(char * string1, char * string2){
    int e=0;
    while(string1[e]!=0){
        if(string1[e]!=string2[e])return 0;
        e++;
    }
    if(string1[e]!=string2[e])return 0;
    return 1;
}

// Funcion que se encarga de convertir una cadena de caracteres a un numero entero
// No se debe completar nada de esta funcion
int convertir(char * string1){
    int e = 0,s=0;
    while(string1[e]!=0){
        s=s*10+(string1[e]-'0');
        e++;
    }
    return s;
}