← Back to branch summary

~ubuntu-branches/ubuntu/raring/hplip/raring

« back to all changes in this revision

Viewing changes to prnt/hpcups/LJZjStream.cpp

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2012-10-06 15:03:44 UTC
  • mfrom: (1.6.1) (20.1.16 quantal)
  • Revision ID: package-import@ubuntu.com-20121006150344-2p3xz26br0t3hu2q
Tags: 3.12.10-1
http://bugs.debian.org/683033
http://bugs.debian.org/687129
* New upstream release
  - Fixes "Network scanning fails (Closes: #683033)
* quilt refresh hplip-syslog-fix-debug-messages-to-error.dpatch
* Fix "error in clean build env" updated debian/rules (Closes: #687129)

Show diffs side-by-side

added added

removed removed

Lines of Context:
prnt/hpcups/LJZjStream.cpp
215
215
    int                 i;
216
216
    int                 width;
217
217
 
 
218
    m_iPlaneNumber = 0;
 
219
    m_iCurRaster   = 0;
218
220
    if((strcmp(m_pJA->printer_platform, "ljzjscolor") == 0) && (m_pJA->printer_platform_version == 2))
219
221
    {
220
222
       return StartPage_ljzjcolor2(pJA);
221
223
    }
222
224
 
223
 
    m_iPlaneNumber = 0;
224
 
    m_iCurRaster   = 0;
225
225
        
226
 
        if (m_pJA->e_duplex_mode == DUPLEXMODE_NONE)
227
 
        {
228
 
                dwNumItems = 14;                
229
 
        }
230
 
        else
231
 
        {
232
 
                dwNumItems = 15;                                
233
 
        }
 
226
    if (m_pJA->e_duplex_mode == DUPLEXMODE_NONE)
 
227
    {
 
228
        dwNumItems = 14;                
 
229
    }
 
230
    else
 
231
    {
 
232
        dwNumItems = 15;                                
 
233
    }
234
234
 
235
235
    width = ((m_pMA->printable_width + 31) / 32) * 32;
236
236
    if (m_pJA->color_mode == 0)
661
661
    return err;
662
662
}
663
663
 
 
664
 
 
665
DRIVER_ERROR LJZjStream::preProcessRasterData(cups_raster_t **ppcups_raster, cups_page_header2_t* firstpage_cups_header, char* pSwapedPagesFileName)
 
666
{
 
667
        int current_page_number = 0;
 
668
        int fdEven = -1;
 
669
        int fdOdd = -1;
 
670
        int fdSwaped = -1;
 
671
        int loopcntr = 0; 
 
672
        DRIVER_ERROR driver_error = NO_ERROR;
 
673
        cups_page_header2_t    cups_header;
 
674
        cups_raster_t *swaped_pages_raster=NULL;
 
675
        cups_raster_t *even_pages_raster=NULL;
 
676
        cups_raster_t *odd_pages_raster = NULL;
 
677
        BYTE* pPageDataBuffer = NULL;
 
678
        char hpEvenPagesFile[64];
 
679
        char hpOddPagesFile[64];
 
680
        snprintf(hpEvenPagesFile, sizeof(hpEvenPagesFile), "%s/hplipEvenPagesXXXXXX","/var/log/hp/tmp");
 
681
        snprintf(hpOddPagesFile, sizeof(hpOddPagesFile), "%s/hplipOddPagesXXXXXX", "/var/log/hp/tmp");
 
682
        
 
683
        if (1 != m_pJA->pre_process_raster || !cups_header.Duplex){                                               
 
684
                return  NO_ERROR;                                  
 
685
    }    
 
686
 
 
687
    dbglog ("DEBUG: Getting Swaped Pages Raster.....\n");
 
688
 
 
689
    memcpy(&cups_header, firstpage_cups_header, sizeof(cups_page_header2_t));
 
690
 
 
691
    //Create temp files to store odd, even and swaped pages.
 
692
        fdEven = mkstemp (hpEvenPagesFile);
 
693
        fdOdd = mkstemp (hpOddPagesFile);
 
694
        fdSwaped = mkstemp (pSwapedPagesFileName);
 
695
        if (fdEven < 0 || fdOdd < 0 || fdSwaped < 0){
 
696
                        dbglog ("ERROR: Unable to open temp output files for writing\n");               
 
697
                        driver_error = SYSTEM_ERROR;
 
698
                        goto bugout;
 
699
        }
 
700
 
 
701
        even_pages_raster = cupsRasterOpen(fdEven, CUPS_RASTER_WRITE);
 
702
        odd_pages_raster = cupsRasterOpen(fdOdd, CUPS_RASTER_WRITE);
 
703
        if (even_pages_raster == NULL || odd_pages_raster == NULL) {
 
704
                dbglog("cupsRasterOpen failed for even_pages_raster or odd_pages_raster\n");
 
705
                driver_error = NULL_POINTER;
 
706
        goto bugout;
 
707
        }
 
708
 
 
709
        pPageDataBuffer = new BYTE[cups_header.cupsBytesPerLine+1];
 
710
        if (pPageDataBuffer == NULL) {
 
711
                driver_error = ALLOCMEM_ERROR;
 
712
        goto bugout;
 
713
    }
 
714
 
 
715
 
 
716
        do
 
717
        {
 
718
                current_page_number++;
 
719
                if(current_page_number % 2) {
 
720
                        cupsRasterWriteHeader2(odd_pages_raster, &cups_header);
 
721
                }
 
722
                else {
 
723
                        cupsRasterWriteHeader2(even_pages_raster, &cups_header);
 
724
                }
 
725
 
 
726
                // Iterating through the raster per page
 
727
                for (int y = 0; y < (int) cups_header.cupsHeight; y++) {
 
728
                        cupsRasterReadPixels (*ppcups_raster, pPageDataBuffer, cups_header.cupsBytesPerLine);
 
729
                        if(current_page_number % 2) {
 
730
                                cupsRasterWritePixels (odd_pages_raster, pPageDataBuffer, cups_header.cupsBytesPerLine);
 
731
                        }
 
732
                        else {
 
733
                                cupsRasterWritePixels (even_pages_raster, pPageDataBuffer, cups_header.cupsBytesPerLine);
 
734
                        }
 
735
                }
 
736
                   
 
737
        } while (cupsRasterReadHeader2(*ppcups_raster, &cups_header)); 
 
738
 
 
739
        cupsRasterClose(even_pages_raster);
 
740
        cupsRasterClose(odd_pages_raster);
 
741
 
 
742
        //Now read even and odd pages rasters and then put into swaped raster 
 
743
        if ((fdEven = open (hpEvenPagesFile, O_RDONLY)) == -1) {
 
744
            perror("ERROR: Unable to open evenpage raster file for reading.");
 
745
                driver_error = SYSTEM_ERROR;
 
746
        goto bugout;
 
747
        }
 
748
 
 
749
        if ((fdOdd = open (hpOddPagesFile, O_RDONLY)) == -1){
 
750
            perror("ERROR: Unable to open odd page raster file for writing. ");
 
751
                driver_error = SYSTEM_ERROR;
 
752
        goto bugout;
 
753
        }
 
754
        even_pages_raster = cupsRasterOpen(fdEven, CUPS_RASTER_READ);
 
755
        odd_pages_raster = cupsRasterOpen(fdOdd, CUPS_RASTER_READ);
 
756
        swaped_pages_raster = cupsRasterOpen(fdSwaped, CUPS_RASTER_WRITE);
 
757
 
 
758
        if (swaped_pages_raster == NULL || even_pages_raster == NULL || odd_pages_raster == NULL) {
 
759
                dbglog("cupsRasterOpen failed for even_pages_raster or odd_pages_raster or swaped_pages_raster\n");
 
760
                driver_error = NULL_POINTER;
 
761
        goto bugout;
 
762
 
 
763
        }
 
764
 
 
765
        loopcntr = current_page_number / 2;
 
766
        while (loopcntr--) {
 
767
                if(cupsRasterReadHeader2(even_pages_raster, &cups_header)){
 
768
                        cupsRasterWriteHeader2(swaped_pages_raster, &cups_header);      
 
769
                
 
770
                        // Iterating through the raster per line
 
771
                        for (int y = 0; y < (int) cups_header.cupsHeight; y++){
 
772
                                cupsRasterReadPixels (even_pages_raster, pPageDataBuffer, cups_header.cupsBytesPerLine);
 
773
                                cupsRasterWritePixels (swaped_pages_raster, pPageDataBuffer, cups_header.cupsBytesPerLine);
 
774
                        }
 
775
                }
 
776
 
 
777
                if(cupsRasterReadHeader2(odd_pages_raster, &cups_header)){
 
778
                        cupsRasterWriteHeader2(swaped_pages_raster, &cups_header);      
 
779
        
 
780
                        // Iterating through the raster per line
 
781
                        for (int y = 0; y < (int) cups_header.cupsHeight; y++) {
 
782
                                cupsRasterReadPixels (odd_pages_raster, pPageDataBuffer, cups_header.cupsBytesPerLine);
 
783
                                cupsRasterWritePixels (swaped_pages_raster, pPageDataBuffer, cups_header.cupsBytesPerLine);
 
784
                        }
 
785
                }
 
786
 
 
787
        }
 
788
 
 
789
    //Last Page is in odd page file
 
790
        if(current_page_number%2 == 1){
 
791
                cupsRasterReadHeader2(odd_pages_raster, &cups_header);
 
792
                cupsRasterWriteHeader2(swaped_pages_raster, &cups_header);      
 
793
        
 
794
                // Iterating through the raster per line
 
795
                for (int y = 0; y < (int) cups_header.cupsHeight; y++){
 
796
                        cupsRasterReadPixels (odd_pages_raster, pPageDataBuffer, cups_header.cupsBytesPerLine);
 
797
                        cupsRasterWritePixels (swaped_pages_raster, pPageDataBuffer, cups_header.cupsBytesPerLine);
 
798
                }
 
799
        }
 
800
 
 
801
        cupsRasterClose(even_pages_raster);
 
802
        cupsRasterClose(odd_pages_raster);
 
803
        cupsRasterClose(swaped_pages_raster);
 
804
 
 
805
    if(pPageDataBuffer){
 
806
            delete [] pPageDataBuffer;
 
807
        pPageDataBuffer = NULL;
 
808
    }
 
809
 
 
810
        //Now send swaped raster file further processing.
 
811
        if ((fdSwaped = open (pSwapedPagesFileName, O_RDONLY)) == -1){
 
812
            perror("ERROR: Unable to open swaped pages raster file - ");
 
813
                driver_error = SYSTEM_ERROR;
 
814
        goto bugout;
 
815
        }
 
816
        
 
817
        *ppcups_raster = cupsRasterOpen(fdSwaped, CUPS_RASTER_READ);
 
818
        cupsRasterReadHeader2(*ppcups_raster, &cups_header);
 
819
    memcpy(firstpage_cups_header, &cups_header, sizeof(cups_page_header2_t));
 
820
    unlink(hpEvenPagesFile);
 
821
    unlink(hpOddPagesFile); 
 
822
 
 
823
    return NO_ERROR; //cups_raster;
 
824
 
 
825
bugout:
 
826
        dbglog ("DEBUG:Something went wrong while creating swaped pages raster..\n");
 
827
        if (fdEven > 2)
 
828
                close(fdEven);
 
829
        if (fdOdd > 2)
 
830
                close(fdOdd);
 
831
        if (fdSwaped > 2)
 
832
                close(fdSwaped);
 
833
                //closeFilter();
 
834
 
 
835
        if(pPageDataBuffer){
 
836
                delete [] pPageDataBuffer;
 
837
        }
 
838
 
 
839
        unlink(hpEvenPagesFile);
 
840
        unlink(hpOddPagesFile); 
 
841
        return driver_error;
 
842
}
 
843