Recherche avancée

Sur d’autres sites (6734)

• Anomalie #4623 : Styles des fieldset dans l’espace privé

  17 avril 2021

  Un peu d’archéologie :

  La classe ".editer_type_fieldset" est Introduite là, là https://git-mirror.spip.net/spip/spip/-/commit/31ff8a5d58c4 avec un message de commit peu explicite (il y a les changements de

  en h3.legend aussi) donc ça doit concerner les facilités de stylages.

  Sur ce commit, "editer_type_fieldset" est conservé (le seul, pour compat ie6 et 7), alors que tous les autres ".editer_type_input" "editer_type_select" et autres ont été supprimés.
  https://git-mirror.spip.net/spip/spip/-/commit/f60b051a98

  Remplacé ensuite de .editer.editer_type_fieldset+ fieldset en .editer.fieldet + fieldset qui sert a priori a enlever le padding du .editer
  https://git-mirror.spip.net/spip/spip/-/commit/e78936ec8

• Anomalie #4623 : Styles des fieldset dans l’espace privé

  16 avril 2021, par RastaPopoulos ♥

  Je mets ici un essai fait un peu à l’arrache hier dans le navigateur que j’ai peaufiné un peu ce matin.

  Les arguments qui vont avec :

  • Je pense que c’est plus léger visuellement à la fois que le master et que dans la branche de cette PR, y compris pour les groupes racines, car il n’y a pas de coupure horizontale. Quand l’œil parcourt de haut en bas, il n’est pas bloqué par des bordures horizontales qui font que l’esprit s’arrête un instant.
  • Les groupes doivent tous être matérialisés par un début et une fin, y compris les groupes racines : il peut y avoir des champs hors groupe après n’importe quel fieldset, et donc on doit savoir où finit un fieldset.
  • Là je matérialise avec une fine ligne de la couleur du thème, que je fais terminer en dégradé vers le transparent afin de ce soit plus doux (ce n’est pas une border mais une background-image gradient de 1px)
  • De cette manière on voit à la fois le début et la fin, sans coupure de lecture, et avec une indication de 1px seulement. Notamment les groupes racines ne sont pas décalés du tout par rapport au reste : l’indication de 1px se superpose à la bordure existante des formulaires. Ainsi comme on le voit, les champs intérieur au premier groupe racine sont pile au même niveau que les champs en dehors du groupe.

  

  Commentaire supplémentaire : cette légère matérialisation ne se base pas sur la couleur mais sur la luminosité, ainsi ça marche même si on est daltonien. Pour appuyer on peut utiliser spip-color-theme-dark, ou si on veut faire plus neutre, on pourrait aussi virer totalement la couleur et utiliser spip-color-gray-dark aussi bien pour la ligne dégradé que pour le legend. Le principe restant le même.

  Version monochrome avec spip-color-gray-dark (plus foncé que précédemment), on voit quand même pas mal la diff à tous les niveaux.

  

• FFmpeg encoding aac audio, encoded file can not be played

  9 décembre 2020, par cs guy

  I am trying to encodea aac audio. Example of MP2 here. I followed this documentation. I encode the audio with the code below by calling startEncoding and after 2 seconds I call stopEncoding. Everything seems to work fine I get an file with some size but the problem is I can not open or play it. I dont know why. I must be doing something wrong in the code.

  


  header :

  


  class MediaEncoder {&#xA;public:&#xA;    MediaEncoder(char *filePath);&#xA;&#xA;    void startEncoding();&#xA;    void stopEncoding();&#xA;&#xA;    void encode(AVFrame *frame);&#xA;    bool isEncoding() const;&#xA;&#xA;    void startEncoderWorker();&#xA;&#xA;    int32_t check_sample_fmt(enum AVSampleFormat sample_fmt);&#xA;    &#xA;    bool signalExitFuture = false;&#xA;    int32_t ret;&#xA;&#xA;private:&#xA;    std::future<void> encodingFuture;&#xA;    AVCodecContext *avCodecContext;&#xA;    AVFrame *avFrame;&#xA;    AVPacket *avPacket;&#xA;    AVCodec *codec;&#xA;    FILE* file;&#xA;};&#xA;</void>

  


  cpp :

  


  MediaEncoder::MediaEncoder(char *filePath){
    buffer = std::make_unique>(recorderBufferSize);

    /* find the encoder */
    codec = avcodec_find_encoder(AV_CODEC_ID_AAC);
    avCodecContext = avcodec_alloc_context3(codec);

    avCodecContext->bit_rate = 64000;

    /* check that the encoder supports given sample format */
    avCodecContext->sample_fmt = AVSampleFormat::AV_SAMPLE_FMT_FLTP;
    
    /* select other audio parameters supported by the encoder */
    avCodecContext->sample_rate = defaultSampleRate;
    avCodecContext->channel_layout = AV_CH_LAYOUT_STEREO;
    avCodecContext->channels = av_get_channel_layout_nb_channels(avCodecContext->channel_layout);

    /* open it */
    avcodec_open2(avCodecContext, codec, nullptr)
    
    file = fopen(filePath, "wb");
    
    /* packet for holding encoded output */
    avPacket = av_packet_alloc();
    
    /* frame containing input raw audio */
    avFrame = av_frame_alloc();
    
    avFrame->nb_samples = avCodecContext->frame_size;
    avFrame->format = avCodecContext->sample_fmt;
    avFrame->channel_layout = avCodecContext->channel_layout;

    /* allocate the data buffers */
    av_frame_get_buffer(avFrame, 0);
}


void MediaEncoder::startEncoding() {
    // set flags for decoding thread
    signalExitFuture = false;

    encodingFuture = std::async(std::launch::async, &MediaEncoder::startEncoderWorker, this);
}

void MediaEncoder::stopEncoding() {
    signalExitFuture = true;
}

bool MediaEncoder::isEncoding() const {
    return !signalExitFuture;
}

void MediaEncoder::encode(AVFrame *frame) {
    /* send the frame for encoding */
    ret = avcodec_send_frame(avCodecContext, frame);
    if (ret < 0) {
        LOGE("Error sending the frame to the encoder %s",
             av_err2str(ret));
        *recorderStatePointer = MediaEncoderState::RUNTIME_FAIL;
        return;
    }

    /* read all the available output packets (in general there may be any
     * number of them */
    while (ret >= 0) {
        ret = avcodec_receive_packet(avCodecContext, avPacket);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
            return;
        } else if (ret < 0) {
            LOGE("Error encoding audio frame %s",
                 av_err2str(ret));
            *recorderStatePointer = MediaEncoderState::RUNTIME_FAIL;
            return;
        }
       
        /* Solution begins here
        int aac_profile = 2;           // AAC LC
        int frequencey_index = 4;      // 44,100Hz
        int channel_configuration = 2; // stereo (left, right)

        int frame_length = avPacket->size + 7;              // your frame length
     
        unsigned char adts_header[7];

        // fill in ADTS data
        adts_header[0] = (unsigned char) 0xFF;
        adts_header[1] = (unsigned char) 0xF9;
        adts_header[2] = (unsigned char) (((aac_profile -1) << 6 ) + (frequencey_index << 2) + (channel_configuration >> 2));
        adts_header[3] = (unsigned char) (((channel_configuration & 3) << 6) + (frame_length >> 11));
        adts_header[4] = (unsigned char) ((frame_length & 0x7FF) >> 3);
        adts_header[5] = (unsigned char) (((frame_length & 7) << 5) + 0x1F);
        adts_header[6] = (unsigned char) 0xFC;

        fwrite(adts_header, 1, 7, file); 
        Solution ends here */ 
        fwrite(avPacket->data, 1, avPacket->size, file);
        av_packet_unref(avPacket);
    }
}

void MediaEncoder::startEncoderWorker() {
    try {
        float *leftChannel;
        float *rightChannel;
        float val;

        while (!signalExitFuture) {
            ret = av_frame_make_writable(avFrame);
            if (ret < 0) {
                LOGE("av_frame_make_writable Can not Ensure that the frame data is writable. %s",
                     av_err2str(ret));
                *recorderStatePointer = MediaEncoderState::RUNTIME_FAIL;
                return;
            }

            leftChannel = (float *) avFrame->data[0];
            rightChannel = (float *) avFrame->data[1];

            for (int32_t i = 0; i < avCodecContext->frame_size; ++i) {
               
                leftChannel[i] = 0.4;
                rightChannel[i] = 0.4;
            }

            encode(avFrame);
        }

        /* flush the encoder */
        encode(nullptr);

        fclose(file);
        LOGE("Encoding finished!");

        av_frame_free(&avFrame);
        av_packet_free(&avPacket);
        avcodec_free_context(&avCodecContext);
    } catch (std::exception &e) {
        LOGE("startEncoderWorker uncaught exception %s", e.what());
    }

    LOGE("Deleting Media Encoder!");

}


  


  Here is an recorded 11 seconds of an aac file recorded with real float pcm data rather than 0.4 as it is in the code I posted. Google Drive Link

  


  The code above works. Thanks to the legend @Markus-Schumann